diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index f1fb38f7d..000000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,154 +0,0 @@
-version: 2
-
-rspec: &rspec
-  steps:
-    - checkout
-    - run: bundle install
-    - run: rake spec
-
-rubocop: &rubocop
-  steps:
-    - checkout
-    - run: bundle install
-    - run: rake internal_investigation
-
-jobs:
-  confirm_config_and_documentation:
-    docker:
-      - image: circleci/ruby
-    steps:
-      - checkout
-      - run: bundle install
-      - run: rake confirm_config documentation_syntax_check confirm_documentation
-
-  # Ruby 2.3
-  ruby-2.3-rspec:
-    docker:
-      - image: circleci/ruby:2.3
-    <<: *rspec
-  ruby-2.3-rubocop:
-    docker:
-      - image: circleci/ruby:2.3
-    <<: *rubocop
-
-  # Ruby 2.4
-  ruby-2.4-rspec:
-    docker:
-      - image: circleci/ruby:2.4
-    <<: *rspec
-  ruby-2.4-rubocop:
-    docker:
-      - image: circleci/ruby:2.4
-    <<: *rubocop
-
-  # Ruby 2.5
-  ruby-2.5-rspec:
-    docker:
-      - image: circleci/ruby:2.5
-    <<: *rspec
-  ruby-2.5-rubocop:
-    docker:
-      - image: circleci/ruby:2.5
-    <<: *rubocop
-
-  # Ruby 2.6
-  ruby-2.6-rspec:
-    docker:
-      - image: circleci/ruby:2.6
-    <<: *rspec
-  ruby-2.6-rubocop:
-    docker:
-      - image: circleci/ruby:2.6
-    <<: *rubocop
-
-  # Ruby 2.7
-  ruby-2.7-rspec:
-    docker:
-      - image: circleci/ruby:2.7
-    <<: *rspec
-  ruby-2.7-rubocop:
-    docker:
-      - image: circleci/ruby:2.7
-    <<: *rubocop
-
-  edge-rubocop:
-    docker:
-      - image: circleci/ruby
-    steps:
-      - checkout
-      - run:
-          name: Use latest RuboCop from `master`
-          command: |
-            echo "gem 'rubocop', github: 'rubocop-hq/rubocop'" > Gemfile.local
-      - run: bundle install --no-cache
-      - run: rake spec
-      - run: rake internal_investigation
-
-  # JRuby
-  jruby:
-    docker:
-      - image: circleci/jruby:9
-    steps:
-      - checkout
-      - run: sudo apt-get install -y make
-      - run: bundle lock
-      - restore_cache:
-          keys:
-            - bundle-v2-{{ checksum "Gemfile.lock" }}
-            - bundle-v2-
-      - run: bundle install --path vendor/bundle
-      - save_cache:
-          key: bundle-v2-{{ checksum "Gemfile.lock" }}
-          paths:
-            - vendor/bundle
-      - run: rake internal_investigation spec
-
-  code-climate:
-    docker:
-      - image: circleci/ruby
-    steps:
-      - checkout
-      - run: bundle install
-      - run:
-          name: Setup Code Climate test-reporter
-          command: |
-            curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-            chmod +x ./cc-test-reporter
-      - run:
-          name: Run specs
-          command: |
-            ./cc-test-reporter before-build
-            rake coverage
-            ./cc-test-reporter after-build --exit-code $?
-
-workflows:
-  version: 2
-  build:
-    jobs:
-      - confirm_config_and_documentation
-
-      # Use `requires: [confirm_config_and_documentation]` to trick Circle CI into starting the slow jruby job early.
-      - ruby-2.3-rspec:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.3-rubocop:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.4-rspec:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.4-rubocop:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.5-rspec:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.5-rubocop:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.6-rspec:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.6-rubocop:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.7-rspec:
-          requires: [confirm_config_and_documentation]
-      - ruby-2.7-rubocop:
-          requires: [confirm_config_and_documentation]
-      - edge-rubocop:
-          requires: [confirm_config_and_documentation]
-      - jruby
-      - code-climate
diff --git a/.codespellignore b/.codespellignore
new file mode 100644
index 000000000..744bd7490
--- /dev/null
+++ b/.codespellignore
@@ -0,0 +1 @@
+xdescribe
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..bc91901da
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,7 @@
+# .git-blame-ignore-revs
+# Add mdformat to the workflow in GitHub Actions
+4874a5a4a2a58e76d343aaa02279cd93b16f5a30
+# Move node patterns into private scope
+089491fb1fa173145f8e6eb1b511d4a7a1bf28ff
+# Don't always define node patterns in private scope
+ce09cb2b25b9f3778bf032d0caaa862da6635b54
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..30abe34a1
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+*  @rubocop/rubocop-rspec
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index eb300f83e..105999a15 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -1,34 +1,93 @@
 # Contributing
 
-If you encounter problems or have ideas for improvements or new features, please report them to the [issue tracker](https://github.com/rubocop-hq/rubocop-rspec/issues) or submit a pull request. Please, try to follow these guidelines when you do so.
+If you encounter problems or have ideas for improvements or new features, please report them to the [issue tracker](https://github.com/rubocop/rubocop-rspec/issues) or submit a pull request. Please, try to follow these guidelines when you do so.
 
 ## Issue reporting
 
-* Check that the issue has not already been reported.
-* Check that the issue has not already been fixed in the latest code (a.k.a. `master`).
-* Check if the issue is a non-goal of RuboCop RSpec.
-* Be clear, concise, and precise in your description of the problem.
-* Open an issue with a descriptive title and a summary in grammatically correct, complete sentences.
-* Report the versions of `rubocop-rspec`, as well as the output of `rubocop -V`.
-* Include any relevant code to the issue summary.
+- Check that the issue has not already been reported.
+- Check that the issue has not already been fixed in the latest code (a.k.a. `master`).
+- Check if the issue is a non-goal of RuboCop RSpec.
+- Be clear, concise, and precise in your description of the problem.
+- Open an issue with a descriptive title and a summary in grammatically correct, complete sentences.
+- Report the versions of `rubocop-rspec`, as well as the output of `rubocop -V`.
+- Include any relevant code to the issue summary.
 
 ## Pull requests
 
-1.  Fork the project.
-2.  Create a feature branch.
-3.  Make sure to add tests.
-4.  Make sure the test suite passes (run `rake`).
-5.  Add a [changelog](https://github.com/rubocop-hq/rubocop-rspec/blob/master/CHANGELOG.md) entry.
-6.  Commit your changes.
-7.  Push to the branch.
-8.  Create new Pull Request.
+1. Fork the project.
+2. Create a feature branch.
+3. Make sure to add tests.
+4. Make sure the test suite passes (run `rake`).
+5. Add a [changelog](https://github.com/rubocop/rubocop-rspec/blob/master/CHANGELOG.md) entry.
+6. Commit your changes.
+7. Push to the branch.
+8. Create new Pull Request.
+
+### Spell Checking
+
+We are running [codespell](https://github.com/codespell-project/codespell) with [GitHub Actions](https://github.com/rubocop/rubocop-rspec/blob/master/.github/workflows/codespell.yml) to check spelling and
+[codespell](https://pypi.org/project/codespell/).
+`codespell` is written in [Python](https://www.python.org/) and you can run it with:
+
+```console
+$ codespell --ignore-words=.codespellignore
+```
+
+### Linting YAML files
+
+We are running [yamllint](https://github.com/adrienverge/yamllint) for linting YAML files. This is also run by [GitHub Actions](https://github.com/rubocop/rubocop-rspec/blob/master/.github/workflows/linting.yml).
+`yamllint` is written in [Python](https://www.python.org/) and you can run it with:
+
+```console
+$ yamllint .
+```
+
+### Formatting Markdown files
+
+We are running [mdformat](https://github.com/executablebooks/mdformat) for formatting Markdown files. This is also run by [GitHub Actions](https://github.com/rubocop/rubocop-rspec/blob/master/.github/workflows/linting.yml).
+`mdformat` is written in [Python](https://www.python.org/) and you can run it with:
+
+```console
+$ mdformat . --number
+```
+
+### Test Coverage - Line and Branch
+
+We are using [Simplecov](https://github.com/colszowka/simplecov) to track test coverage.
+
+It is included and reported when you run `bundle exec rake` or `bundle exec rspec`.
+
+To view the coverage report, open the `coverage/index.html` file in your browser.
+
+E.g. on macOS:
+
+```console
+$ open coverage/index.html
+```
+
+If you have unreachable lines, you can add `# :nocov` around those lines. The code itself or a comment should explain why the line is unreachable.
+
+Example:
+
+```ruby
+# :nocov:
+raise ArgumentError("Unsupported style :#{style}")
+# :nocov:
+```
+
+This can happen for a few reasons, including:
+
+1. When you handle config with a case statement and there is no else block.
+2. When matching with a node pattern even when you handle all cases: all other node types will be excluded before reaching your handler, because the node pattern will not match them.
+
+You will need full line and branch coverage to merge. This helps detect edge cases and prevent errors.
 
 ## Creating new cops
 
-* Document examples of good and bad code in your cop.
-* Add an entry to `config/default.yml`. It's an ordered list, so be sure to insert at the appropriate place.
-* Run `bundle exec rake`. This will verify that the build passes as well as generate documentation and ensure that `config/default.yml` is up to date (don't forget to commit the documentation).
-* Add tests for as many use cases as you can think of. Always add tests for both bad code that should register an offense and good code that should not.
-* Common pitfalls:
-  * If your cop inspects code outside of an example, check for false positives when similarly named variables are used inside of the example.
-  * If your cop inspects code inside of an example, check that it works when the example is empty (empty `describe`, `it`, etc.).
+- Document examples of good and bad code in your cop.
+- Add an entry to `config/default.yml`. It's an ordered list, so be sure to insert at the appropriate place.
+- Run `bundle exec rake`. This will verify that the build passes as well as generate documentation and ensure that `config/default.yml` is up to date (don't forget to commit the documentation).
+- Add tests for as many use cases as you can think of. Always add tests for both bad code that should register an offense and good code that should not.
+- Common pitfalls:
+  - If your cop inspects code outside of an example, check for false positives when similarly named variables are used inside of the example.
+  - If your cop inspects code inside of an example, check that it works when the example is empty (empty `describe`, `it`, etc.).
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 000000000..e356c939e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,48 @@
+---
+name: Bug Report
+about: Report an issue with RuboCop RSpec you've discovered.
+---
+
+*Be clear, concise and precise in your description of the problem.
+Open an issue with a descriptive title and a summary in grammatically correct,
+complete sentences.*
+
+*Use the template below when reporting bugs. Please, make sure that
+you're running the latest stable RuboCop RSpec and that the problem you're reporting
+hasn't been reported (and potentially fixed) already.*
+
+*Before filing the ticket you should replace all text above the horizontal
+rule with your own words.*
+
+*In the case of false positive or false negative, please add the
+corresponding cop name.*
+
+______________________________________________________________________
+
+## Expected behavior
+
+Describe here how you expected RuboCop RSpec to behave in this particular situation.
+
+## Actual behavior
+
+Describe here what actually happened.
+Please use `rubocop --debug` when pasting rubocop output as it contains additional information.
+
+## Steps to reproduce the problem
+
+This is extremely important! Providing us with a reliable way to reproduce
+a problem will expedite its solution.
+
+## RuboCop RSpec version
+
+Include the output of `rubocop -V` or `bundle exec rubocop -V` if using Bundler.
+If you see extension cop versions (e.g. `rubocop-performance`, `rubocop-rake`, and others)
+output by `rubocop -V`, include them as well. Here's an example:
+
+```shell
+$ [bundle exec] rubocop -V
+1.67.0 (using Parser 3.3.5.0, rubocop-ast 1.32.3, analyzing as Ruby 2.7, running on ruby 3.4.0) [arm64-darwin23]
+  - rubocop-performance 1.22.1
+  - rubocop-rake 0.6.0
+  - rubocop-rspec 3.1.0
+```
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 000000000..0cffb2019
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature Request
+about: Suggest new RuboCop RSpec features or improvements to existing features.
+---
+
+## Is your feature request related to a problem? Please describe.
+
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+## Describe the solution you'd like
+
+A clear and concise description of what you want to happen.
+
+## Describe alternatives you've considered
+
+A clear and concise description of any alternative solutions or features you've considered.
+
+## Additional context
+
+Add any other context or screenshots about the feature request here.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 3b40d7539..8695fedf6 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -1,17 +1,25 @@
 **Replace this text with a summary of the changes in your PR. The more detailed you are, the better.**
 
----
+______________________________________________________________________
 
 Before submitting the PR make sure the following are checked:
 
-* [ ] Feature branch is up-to-date with `master` (if not - rebase it).
-* [ ] Squashed related commits together.
-* [ ] Added tests.
-* [ ] Added an entry to the [changelog](https://github.com/rubocop-hq/rubocop-rspec/blob/master/CHANGELOG.md) if the new code introduces user-observable changes.
-* [ ] The build (`bundle exec rake`) passes (be sure to run this locally, since it may produce updated documentation that you will need to commit).
+- [ ] Feature branch is up-to-date with `master` (if not - rebase it).
+- [ ] Squashed related commits together.
+- [ ] Added tests.
+- [ ] Updated documentation.
+- [ ] Added an entry to the `CHANGELOG.md` if the new code introduces user-observable changes.
+- [ ] The build (`bundle exec rake`) passes (be sure to run this locally, since it may produce updated documentation that you will need to commit).
 
 If you have created a new cop:
 
-* [ ] Added the new cop to `config/default.yml`.
-* [ ] The cop documents examples of good and bad code.
-* [ ] The tests assert both that bad code is reported and that good code is not reported.
+- [ ] Added the new cop to `config/default.yml`.
+- [ ] The cop is configured as `Enabled: pending` in `config/default.yml`.
+- [ ] The cop is configured as `Enabled: true` in `.rubocop.yml`.
+- [ ] The cop documents examples of good and bad code.
+- [ ] The tests assert both that bad code is reported and that good code is not reported.
+- [ ] Set `VersionAdded: "<<next>>"` in `default/config.yml`.
+
+If you have modified an existing cop's configuration options:
+
+- [ ] Set `VersionChanged: "<<next>>"` in `config/default.yml`.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..b18fd2935
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
diff --git a/.github/workflows/codespell.yml b/.github/workflows/codespell.yml
new file mode 100644
index 000000000..3a7b82333
--- /dev/null
+++ b/.github/workflows/codespell.yml
@@ -0,0 +1,18 @@
+name: CodeSpell
+on:
+  - pull_request
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+jobs:
+  codespell:
+    name: CodeSpell
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: CodeSpell
+        uses: codespell-project/actions-codespell@master
+        with:
+          check_filenames: true
+          check_hidden: true
+          ignore_words_file: .codespellignore
diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml
new file mode 100644
index 000000000..9876c082e
--- /dev/null
+++ b/.github/workflows/linting.yml
@@ -0,0 +1,31 @@
+name: Linting
+on:
+  - pull_request
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+jobs:
+  yamllint:
+    name: Yamllint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Yamllint
+        uses: karancode/yamllint-github-action@master
+        with:
+          yamllint_strict: true
+          yamllint_format: parsable
+          yamllint_comment: true
+        env:
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  mdformat:
+    name: Mdformat
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Mdformat
+        uses: ydah/mdformat-action@main
+        with:
+          number: true
+        env:
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
new file mode 100644
index 000000000..88f234e1c
--- /dev/null
+++ b/.github/workflows/main.yml
@@ -0,0 +1,145 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  confirm_config_and_documentation:
+    runs-on: ubuntu-latest
+    name: Confirm config and documentation
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - run: bundle exec rake confirm_config documentation_syntax_check confirm_documentation
+
+  main:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby:
+          - "2.7"
+          - "3.0"
+          - "3.1"
+          - "3.2"
+          - "3.3"
+          - "3.4"
+          - ruby-head
+          - jruby-9.4
+        task:
+          - internal_investigation
+          - spec
+    name: "Ruby ${{ matrix.ruby }}: ${{ matrix.task }}"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "${{ matrix.ruby }}"
+          bundler-cache: true
+      - run: NO_COVERAGE=true bundle exec rake ${{ matrix.task }}
+
+  coverage:
+    runs-on: ubuntu-latest
+    name: "Test coverage"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - run: bundle exec rake spec
+
+  edge-rubocop:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        task:
+          - internal_investigation
+          - spec
+    name: "Edge RuboCop: ${{ matrix.task }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use latest RuboCop from `master`
+        run: |
+          echo "gem 'rubocop', github: 'rubocop/rubocop'" > Gemfile.local
+          cat Gemfile.local
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - name: Show RuboCop version
+        run: grep '^    rubocop' Gemfile.lock | sort
+      - run: NO_COVERAGE=true bundle exec rake ${{ matrix.task }}
+
+  oldest-rubocop:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        task:
+          - spec
+    name: "Oldest RuboCop: ${{ matrix.task }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use oldest RuboCop allowed by gemspec
+        run: |
+          sed -nr "s/ *spec.add_dependency 'rubocop'.*'>= ([0-9\.]+)'/gem 'rubocop', '= \1'/p" \
+            rubocop-rspec.gemspec > Gemfile.local
+          cat Gemfile.local
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - name: Show RuboCop version
+        run: grep '^    rubocop' Gemfile.lock | sort
+      - run: NO_COVERAGE=true bundle exec rake ${{ matrix.task }}
+
+  rspec4:
+    runs-on: ubuntu-latest
+    name: RSpec 4
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use latest RSpec 4 from `4-0-dev` branch
+        run: |
+          sed -e '/rspec/d' -i Gemfile
+          cat << EOF > Gemfile.local
+            gem 'rspec', github: 'rspec/rspec', branch: '4-0-dev'
+            gem 'rspec-core', github: 'rspec/rspec', branch: '4-0-dev'
+            gem 'rspec-expectations', github: 'rspec/rspec', branch: '4-0-dev'
+            gem 'rspec-mocks', github: 'rspec/rspec', branch: '4-0-dev'
+            gem 'rspec-support', github: 'rspec/rspec', branch: '4-0-dev'
+          EOF
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+      - run: NO_COVERAGE=true bundle exec rake spec
+
+  prism:
+    runs-on: ubuntu-latest
+    name: Prism
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use prism parser
+        run: |
+          cat << EOF > Gemfile.local
+            gem 'prism'
+          EOF
+      - name: set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          # Specify the minimum Ruby version 2.7 required for Prism to run.
+          ruby-version: "2.7"
+          bundler-cache: true
+      - env:
+          NO_COVERAGE: true
+          PARSER_ENGINE: parser_prism
+        run: bundle exec rake spec
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 000000000..4fe16c6dc
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,46 @@
+name: Publish
+on:
+  push:
+    branches: master
+    paths: lib/rubocop/rspec/version.rb
+jobs:
+  publish:
+    name: Publish to RubyGems
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'rubocop'
+    permissions:
+      actions: write
+      contents: write
+      id-token: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+      - uses: rubygems/release-gem@v1
+      - name: Create a GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          bundle exec rake create_release_notes
+          gh release create $(git tag --points-at @) \
+            --title "RuboCop RSpec $(git tag --points-at @)" \
+            --notes-file relnotes.md
+      - name: Replace version in Antora config
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          sed -i 's/version:.*$/version: ~/' docs/antora.yml
+          if ! git diff --exit-code docs/antora.yml; then
+            branch=switch-docs-version-$(git tag --points-at @)
+            git config user.name "${GITHUB_ACTOR}"
+            git config user.email "${GITHUB_ACTOR}@users.noreply.github.com"
+            git checkout -b "$branch"
+            git add docs/antora.yml
+            git commit -m "Switch docs version back"
+            git push -u origin "$branch"
+            gh pr create --fill --head "$branch"
+          fi
diff --git a/.gitignore b/.gitignore
index 4970ee61e..9669bf146 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,3 @@
-# rcov generated
-coverage
-coverage.data
-
 # rdoc generated
 rdoc
 
@@ -21,3 +17,11 @@ pkg
 
 .ruby-gemset
 .ruby-version
+
+# simplecov generated
+coverage
+
+# vscode generated
+.vscode
+
+/relnotes.md
diff --git a/.rspec b/.rspec
index 4e33a322b..5be63fcb0 100644
--- a/.rspec
+++ b/.rspec
@@ -1,3 +1,2 @@
 --require spec_helper
---color
 --format documentation
diff --git a/.rubocop.yml b/.rubocop.yml
index a0b9122b9..e8625243b 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,50 +1,295 @@
 inherit_from: .rubocop_todo.yml
-require:
- - rubocop-rspec
- - rubocop/cop/internal_affairs
+
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+  - rubocop-internal_affairs
 
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.7
+  NewCops: disable
   Exclude:
     - 'vendor/**/*'
     - 'spec/fixtures/**/*'
     - 'tmp/**/*'
     - 'spec/smoke_tests/**/*.rb'
 
-# See https://github.com/rubocop-hq/rubocop/issues/6410
+InternalAffairs/OnSendWithoutOnCSend:
+  Enabled: false
+
 Layout/HashAlignment:
+  EnforcedHashRocketStyle:
+    - key
+    - table
+  EnforcedColonStyle:
+    - key
+    - table
+
+Layout/LineLength:
+  Max: 80 # default: 120
+  AllowedPatterns:
+    - '^\s*# .*https?:\/\/.+\[.+\]\.?$' # Allow long asciidoc links
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Lint/InterpolationCheck:
+  Exclude:
+    - spec/**/*.rb
+
+# When the `edge-rubocop` build is red, and we decide to disable the cop,
+# the rest of the builds become red if the cop has not yet been released.
+# Instead of waiting for RuboCop releases to make `edge-rubocop` green,
+# we prefer keeping disable directives here and there and check if they
+# are still needed once in a while.
+Lint/RedundantCopDisableDirective:
   Enabled: false
 
+Lint/UselessAccessModifier:
+  MethodCreatingMethods:
+    - def_node_matcher
+    - def_node_search
+
 Metrics/BlockLength:
   Exclude:
     - rubocop-rspec.gemspec
     - Rakefile
     - '**/*.rake'
-    - spec/**/*.rb
+
+Metrics/MethodLength:
+  Max: 15
 
 Naming/FileName:
   Exclude:
     - lib/rubocop-rspec.rb
 
-Layout/MultilineMethodCallIndentation:
-  EnforcedStyle: indented
+Naming/InclusiveLanguage:
+  Enabled: true
+  CheckStrings: true
+  FlaggedTerms:
+    ' a offense':
+      Suggestions:
+        - an offense
+    auto-correct:
+      Suggestions:
+        - autocorrect
+    auto_correct:
+      Suggestions:
+        - autocorrect
+    ' a violation':
+      Suggestions:
+        - an offense
+    behaviour:
+      Suggestions:
+        - behavior
+    offence:
+      Suggestions:
+        - offense
+    'does not registers':
+      Suggestions:
+        - does not register
+    violation:
+      Suggestions:
+        - offense
+    'register no offense':
+      Suggestions:
+        - registers no offense
 
-Layout/MultilineOperationIndentation:
-  EnforcedStyle: indented
-
-Lint/BooleanSymbol:
-  Exclude:
-    - lib/rubocop/cop/rspec/expect_actual.rb
-    - lib/rubocop/cop/rspec/focus.rb
+RSpec:
+  Language:
+    Expectations:
+      - expect_correction
+      - expect_no_offenses
+      - expect_offense
 
-Lint/InterpolationCheck:
+RSpec/DescribeClass:
   Exclude:
-    - spec/**/*.rb
+    - spec/project/**/*.rb
 
 RSpec/ExampleLength:
-  Max: 30
+  CountAsOne:
+    - heredoc
+  Max: 11
 
-RSpec/DescribeClass:
+RSpec/MultipleExpectations:
+  Max: 2
+
+RSpec/SpecFilePathFormat:
   Exclude:
-    - spec/project/**/*.rb
+    - spec/rubocop/cop/rspec/mixin/**/*.rb
+
+# `expect_offense` does not use Kernel#format or String#%
+Style/FormatStringToken:
+  Exclude:
+    - spec/rubocop/**/*.rb
+
+Style/NumberedParameters:
+  Enabled: true
+  EnforcedStyle: disallow
+
+Style/RequireOrder:
+  Enabled: true
+
+# Enable RuboCop's pending cops up to v1.72
+
+Gemspec/AddRuntimeDependency: {Enabled: true}
+Gemspec/DeprecatedAttributeAssignment: {Enabled: true}
+Gemspec/DevelopmentDependencies: {Enabled: true}
+Gemspec/RequireMFA: {Enabled: true}
+Layout/LineContinuationLeadingSpace: {Enabled: true}
+Layout/LineContinuationSpacing: {Enabled: true}
+Layout/LineEndStringConcatenationIndentation: {Enabled: true}
+Layout/SpaceBeforeBrackets: {Enabled: true}
+Lint/AmbiguousAssignment: {Enabled: true}
+Lint/AmbiguousOperatorPrecedence: {Enabled: true}
+Lint/AmbiguousRange: {Enabled: true}
+Lint/ArrayLiteralInRegexp: {Enabled: true}
+Lint/ConstantOverwrittenInRescue: {Enabled: true}
+Lint/ConstantReassignment: {Enabled: true}
+Lint/CopDirectiveSyntax: {Enabled: true}
+Lint/DeprecatedConstants: {Enabled: true}
+Lint/DuplicateBranch: {Enabled: true}
+Lint/DuplicateMagicComment: {Enabled: true}
+Lint/DuplicateMatchPattern: {Enabled: true}
+Lint/DuplicateRegexpCharacterClassElement: {Enabled: true}
+Lint/DuplicateSetElement: {Enabled: true}
+Lint/EmptyBlock: {Enabled: true}
+Lint/EmptyClass: {Enabled: true}
+Lint/EmptyInPattern: {Enabled: true}
+Lint/HashNewWithKeywordArgumentsAsDefault: {Enabled: true}
+Lint/IncompatibleIoSelectWithFiberScheduler: {Enabled: true}
+Lint/ItWithoutArgumentsInBlock: {Enabled: true}
+Lint/LambdaWithoutLiteralBlock: {Enabled: true}
+Lint/LiteralAssignmentInCondition: {Enabled: true}
+Lint/MixedCaseRange: {Enabled: true}
+Lint/NonAtomicFileOperation: {Enabled: true}
+Lint/NoReturnInBeginEndBlocks: {Enabled: true}
+Lint/NumberedParameterAssignment: {Enabled: true}
+Lint/NumericOperationWithConstantResult: {Enabled: true}
+Lint/OrAssignmentToConstant: {Enabled: true}
+Lint/RedundantDirGlobSort: {Enabled: true}
+Lint/RedundantRegexpQuantifiers: {Enabled: true}
+Lint/RedundantTypeConversion: {Enabled: true}
+Lint/RefinementImportMethods: {Enabled: true}
+Lint/RequireRangeParentheses: {Enabled: true}
+Lint/RequireRelativeSelfPath: {Enabled: true}
+Lint/SharedMutableDefault: {Enabled: true}
+Lint/SuppressedExceptionInNumberConversion: {Enabled: true}
+Lint/SymbolConversion: {Enabled: true}
+Lint/ToEnumArguments: {Enabled: true}
+Lint/TripleQuotes: {Enabled: true}
+Lint/UnescapedBracketInRegexp: {Enabled: true}
+Lint/UnexpectedBlockArity: {Enabled: true}
+Lint/UnmodifiedReduceAccumulator: {Enabled: true}
+Lint/UselessConstantScoping: {Enabled: true}
+Lint/UselessDefined: {Enabled: true}
+Lint/UselessNumericOperation: {Enabled: true}
+Lint/UselessRescue: {Enabled: true}
+Lint/UselessRuby2Keywords: {Enabled: true}
+Metrics/CollectionLiteralLength: {Enabled: true}
+Naming/BlockForwarding: {Enabled: true}
+Security/CompoundHash: {Enabled: true}
+Security/IoMethods: {Enabled: true}
+Style/AmbiguousEndlessMethodDefinition: {Enabled: true}
+Style/ArgumentsForwarding: {Enabled: true}
+Style/ArrayIntersect: {Enabled: true}
+Style/BitwisePredicate: {Enabled: true}
+Style/CollectionCompact: {Enabled: true}
+Style/CombinableDefined: {Enabled: true}
+Style/ComparableClamp: {Enabled: true}
+Style/ConcatArrayLiterals: {Enabled: true}
+Style/DataInheritance: {Enabled: true}
+Style/DigChain: {Enabled: true}
+Style/DirEmpty: {Enabled: true}
+Style/DocumentDynamicEvalDefinition: {Enabled: true}
+Style/EmptyHeredoc: {Enabled: true}
+Style/EndlessMethod: {Enabled: true}
+Style/EnvHome: {Enabled: true}
+Style/ExactRegexpMatch: {Enabled: true}
+Style/FetchEnvVar: {Enabled: true}
+Style/FileEmpty: {Enabled: true}
+Style/FileNull: {Enabled: true}
+Style/FileRead: {Enabled: true}
+Style/FileTouch: {Enabled: true}
+Style/FileWrite: {Enabled: true}
+Style/HashConversion: {Enabled: true}
+Style/HashExcept: {Enabled: true}
+Style/HashSlice: {Enabled: true}
+Style/IfWithBooleanLiteralBranches: {Enabled: true}
+Style/InPatternThen: {Enabled: true}
+Style/ItAssignment: {Enabled: true}
+Style/KeywordArgumentsMerging: {Enabled: true}
+Style/MagicCommentFormat: {Enabled: true}
+Style/MapCompactWithConditionalBlock: {Enabled: true}
+Style/MapIntoArray: {Enabled: true}
+Style/MapToHash: {Enabled: true}
+Style/MapToSet: {Enabled: true}
+Style/MinMaxComparison: {Enabled: true}
+Style/MultilineInPatternThen: {Enabled: true}
+Style/NegatedIfElseCondition: {Enabled: true}
+Style/NestedFileDirname: {Enabled: true}
+Style/NilLambda: {Enabled: true}
+Style/NumberedParametersLimit: {Enabled: true}
+Style/ObjectThen: {Enabled: true}
+Style/OpenStructUse: {Enabled: true}
+Style/OperatorMethodCall: {Enabled: true}
+Style/QuotedSymbols: {Enabled: true}
+Style/RedundantArgument: {Enabled: true}
+Style/RedundantArrayConstructor: {Enabled: true}
+Style/RedundantConstantBase: {Enabled: true}
+Style/RedundantCurrentDirectoryInPath: {Enabled: true}
+Style/RedundantDoubleSplatHashBraces: {Enabled: true}
+Style/RedundantEach: {Enabled: true}
+Style/RedundantFilterChain: {Enabled: true}
+Style/RedundantFormat: {Enabled: true}
+Style/RedundantHeredocDelimiterQuotes: {Enabled: true}
+Style/RedundantInitialize: {Enabled: true}
+Style/RedundantInterpolationUnfreeze: {Enabled: true}
+Style/RedundantLineContinuation: {Enabled: true}
+Style/RedundantRegexpArgument: {Enabled: true}
+Style/RedundantRegexpConstructor: {Enabled: true}
+Style/RedundantSelfAssignmentBranch: {Enabled: true}
+Style/RedundantStringEscape: {Enabled: true}
+Style/ReturnNilInPredicateMethodDefinition: {Enabled: true}
+Style/SafeNavigationChainLength: {Enabled: true}
+Style/SelectByRegexp: {Enabled: true}
+Style/SendWithLiteralMethodName: {Enabled: true}
+Style/SingleLineDoEndBlock: {Enabled: true}
+Style/StringChars: {Enabled: true}
+Style/SuperArguments: {Enabled: true}
+Style/SuperWithArgsParentheses: {Enabled: true}
+Style/SwapValues: {Enabled: true}
+Style/YAMLFileRead: {Enabled: true}
+
+# Enable RuboCop Performance's pending cops up to v1.24
+
+Performance/AncestorsInclude: {Enabled: true}
+Performance/BigDecimalWithNumericArgument: {Enabled: true}
+Performance/BlockGivenWithExplicitBlock: {Enabled: true}
+Performance/CollectionLiteralInLoop: {Enabled: true}
+Performance/ConcurrentMonotonicTime: {Enabled: true}
+Performance/ConstantRegexp: {Enabled: true}
+Performance/MapCompact: {Enabled: true}
+Performance/MapMethodChain: {Enabled: true}
+Performance/MethodObjectAsBlock: {Enabled: true}
+Performance/RedundantEqualityComparisonBlock: {Enabled: true}
+Performance/RedundantSortBlock: {Enabled: true}
+Performance/RedundantSplitRegexpArgument: {Enabled: true}
+Performance/RedundantStringChars: {Enabled: true}
+Performance/ReverseFirst: {Enabled: true}
+Performance/SortReverse: {Enabled: true}
+Performance/Squeeze: {Enabled: true}
+Performance/StringBytesize: {Enabled: true}
+Performance/StringIdentifierArgument: {Enabled: true}
+Performance/StringInclude: {Enabled: true}
+Performance/Sum: {Enabled: true}
+Performance/ZipWithoutBlock: {Enabled: true}
+
+# Enable our own pending cops.
+
+RSpec/IncludeExamples: {Enabled: true}
diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml
index d6a65b650..fb7116182 100644
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,17 +1,11 @@
 # This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2019-12-12 15:15:34 +0200 using RuboCop version 0.77.0.
+# `rubocop --auto-gen-config --no-offense-counts --no-auto-gen-timestamp`
+# using RuboCop version 1.72.1.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 9
-# Cop supports --auto-correct.
-InternalAffairs/MethodNameEqual:
-  Enabled: false
-
-# Offense count: 1
-# Configuration parameters: CountComments.
-Metrics/ClassLength:
-  Max: 104
+Rake/MethodDefinitionInTask:
+  Exclude:
+    - 'tasks/cut_release.rake'
diff --git a/.simplecov b/.simplecov
new file mode 100644
index 000000000..2b29bd2ba
--- /dev/null
+++ b/.simplecov
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+SimpleCov.start do
+  enable_coverage :branch
+  minimum_coverage line: 100, branch: 100
+  add_filter '/spec/'
+  add_filter '/vendor/bundle/'
+end
diff --git a/.yamllint b/.yamllint
new file mode 100644
index 000000000..eae05bc43
--- /dev/null
+++ b/.yamllint
@@ -0,0 +1,11 @@
+extends: default
+
+rules:
+  comments:
+    min-spaces-from-content: 1
+  document-start: disable
+  line-length:
+    allow-non-breakable-inline-mappings: true
+    max: 100
+  truthy:
+    check-keys: false
diff --git a/.yardopts b/.yardopts
new file mode 100644
index 000000000..4419be7d6
--- /dev/null
+++ b/.yardopts
@@ -0,0 +1,3 @@
+--markup markdown
+--hide-void-return
+--tag safety:"Cop Safety Information"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b7897bccd..8d7652184 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,203 +1,714 @@
-# Change log
+# Changelog
 
 ## Master (Unreleased)
 
+- Mark `RSpec/IncludeExamples` as `SafeAutoCorrect: false`. ([@yujideveloper])
+- Fix a false positive for `RSpec/LeakyConstantDeclaration` when defining constants in explicit namespaces. ([@naveg])
+
+## 3.6.0 (2025-04-18)
+
+- Fix false positive in `RSpec/Pending`, where it would mark the default block `it` as an offense. ([@bquorning])
+- Fix issue when `Style/ContextWording` is configured with a Prefix being interpreted as a boolean, like `on`. ([@sakuro])
+- Add new `RSpec/IncludeExamples` cop to enforce using `it_behaves_like` over `include_examples`. ([@dvandersluis])
+- Change `RSpec/ScatteredSetup` to allow `around` hooks to be scattered. ([@ydah])
+- Fix an error `RSpec/ChangeByZero` cop when without expect block. ([@lee266])
+- Fix a false positive for `RSpec/DescribedClass` when `SkipBlocks` is true and numblocks are used. ([@earlopain])
+
+## 3.5.0 (2025-02-16)
+
+- Don't let `RSpec/PredicateMatcher` replace `respond_to?` with two arguments with the RSpec `respond_to` matcher. ([@bquorning])
+- Fix `RSpec/PredicateMatcher` support for `eql` and `equal` matchers. ([@bquorning])
+- Pluginfy RuboCop RSpec. ([@koic])
+
+## 3.4.0 (2025-01-20)
+
+- Fix `RSpec/SortMetadata` cop to limit sorting to trailing metadata arguments. ([@cbliard])
+- Replace `RSpec/StringAsInstanceDoubleConstant` with `RSpec/VerifiedDoubleReference` configured to only support constant class references. ([@corsonknowles])
+- Fix `RSpec/EmptyExampleGroup` cop false positive when a simple conditional is used inside an iterator. ([@lovro-bikic])
+
+## 3.3.0 (2024-12-12)
+
+- Deprecate `top_level_group?` method from `TopLevelGroup` mixin as all of its callers were intentionally removed from `Rubocop/RSpec`. ([@corsonknowles])
+- Fix false positive for RSpec/EmptyMetadata for splat kwargs. ([@pirj])
+
+## 3.2.0 (2024-10-26)
+
+- Fix `RSpec/VoidExpect` to only operate inside an example block. ([@corsonknowles])
+- Change `RSpec/ContextWording` cop to always report an offense when both `Prefixes` and `AllowedPatterns` are empty. ([@ydah])
+- Add support for `and` and `or` compound matchers to `RSpec/ChangeByZero` cop. ([@ydah])
+
+## 3.1.0 (2024-10-01)
+
+- Add `RSpec/StringAsInstanceDoubleConstant` to check for and correct strings used as instance_doubles. ([@corsonknowles])
+- Fix false-positive for `RSpec/UnspecifiedException` when a method is literally named `raise_exception`. ([@aarestad])
+- Fix false-positive for `RSpec/UnspecifiedException` when `not_to raise_error` is used within a block. ([@aarestad], [@G-Rath])
+
+## 3.0.5 (2024-09-07)
+
+- Fix false-negative and error for `RSpec/MetadataStyle` when non-literal args are used in metadata in `EnforceStyle: hash`. ([@cbliard])
+- Improve offense message for `RSpec/IndexedLet`. ([@earlopain])
+
+## 3.0.4 (2024-08-05)
+
+- Fix false-negative for `UnspecifiedException` when matcher is chained. ([@r7kamura])
+
+## 3.0.3 (2024-07-12)
+
+- Add support for Unicode RIGHT SINGLE QUOTATION MARK in `RSpec/ExampleWording`. ([@jdufresne])
+- Suppress deprecation warning for `RSpec/MultipleExpectations`, `RSpec/MultipleMemoizedHelpers`, and `RSpec/NestedGroups` cops. ([@koic])
+
+## 3.0.2 (2024-07-02)
+
+- Fix wrong autocorrect for `RSpec/ScatteredSetup` when hook contains heredoc. ([@earlopain])
+- Fix false negative for `RSpec/PredicateMatcher` when expectation contains custom failure message. ([@earlopain])
+- Facilitate the 3.0 upgrade flow with proper extracted cop messages. ([@jeppester])
+
+## 3.0.1 (2024-06-11)
+
+- Bump RuboCop requirement to +1.61. ([@ydah])
+
+## 3.0.0 (2024-06-11)
+
+- Remove extracted cops in `Capybara`, `FactoryBot` and `Rails` departments. ([@ydah])
+- Remove `RuboCop::RSpec::Language::NodePattern`. ([@ydah])
+- Remove `RSpec/FilePath` cop. ([@ydah])
+- Remove `RSpec/Capybara/FeatureMethods` cop. If you are using this cop, change it to use `RSpec/Dialect`. ([@ydah])
+- Add new `RSpec/MissingExpectationTargetMethod` cop. ([@krororo])
+- Fix an error for `RSpec/ScatteredSetup` when one of the hooks is an empty block. ([@earlopain])
+
+These previously pending cops are now enabled by default: `RSpec/BeEmpty`, `RSpec/BeEq`, `RSpec/BeNil`, `RSpec/ChangeByZero`, `RSpec/ClassCheck`, `RSpec/ContainExactly`, `RSpec/DuplicatedMetadata`, `RSpec/EmptyMetadata`, `RSpec/EmptyOutput`, `RSpec/Eq`, `RSpec/ExcessiveDocstringSpacing`, `RSpec/ExpectInLet`, `RSpec/IdenticalEqualityAssertion`, `RSpec/IndexedLet`, `RSpec/IsExpectedSpecify`, `RSpec/MatchArray`, `RSpec/MetadataStyle`, `RSpec/NoExpectationExample`, `RSpec/PendingWithoutReason`, `RSpec/ReceiveMessages`, `RSpec/RedundantAround`, `RSpec/RedundantPredicateMatcher`, `RSpec/RemoveConst`, `RSpec/RepeatedSubjectCall`, `RSpec/SkipBlockInsideExample`, `RSpec/SortMetadata`, `RSpec/SpecFilePathFormat`, `RSpec/SpecFilePathSuffix`, `RSpec/SubjectDeclaration`, `RSpec/UndescriptiveLiteralsDescription`, and `RSpec/VerifiedDoubleReference`.
+
+Read more about how to upgrade in https://docs.rubocop.org/rubocop-rspec/upgrade_to_version_3.html
+
+## 2.31.0 (2024-06-07)
+
+- Support `AutoCorrect: contextual` option for LSP. ([@ydah])
+
+## 2.30.0 (2024-06-03)
+
+- Add new `RSpec/ExpectInLet` cop. ([@yasu551])
+
+## 2.29.2 (2024-05-02)
+
+- Fix beginless and endless range bug for RepeatedIncludeExample cop. ([@hasghari])
+- Fix a false positive for `RSpec/RepeatedSubjectCall` when subject is used as argument to function call. ([@K-S-A])
+
+## 2.29.1 (2024-04-05)
+
+- Fix an error in the default configuration. ([@ydah])
+
+## 2.29.0 (2024-04-04)
+
+- Fix an autocorrect error for `RSpec/ExpectActual`. ([@bquorning])
+- Add new `RSpec/UndescriptiveLiteralsDescription` cop. ([@ydah])
+- Add new `RSpec/EmptyOutput` cop. ([@bquorning])
+
+## 2.28.0 (2024-03-30)
+
+- Extract RSpec Rails cops to a separate repository, [`rubocop-rspec_rails`](https://github.com/rubocop/rubocop-rspec_rails). The `rubocop-rspec_rails` repository is a dependency of `rubocop-rspec` and the cops related to rspec-rails are aliased (`RSpec/Rails/Foo` == `RSpecRails/Foo`) until v3.0 is released, so the change will be invisible to users until then. ([@ydah])
+
+## 2.27.1 (2024-03-03)
+
+- Fix a false positive for `RSpec/RepeatedSubjectCall` when `subject.method_call`. ([@ydah])
+- Add configuration option `OnlyStaticConstants` to `RSpec/DescribedClass`. ([@ydah])
+
+## 2.27.0 (2024-03-01)
+
+- Add new `RSpec/IsExpectedSpecify` cop. ([@ydah])
+- Add new `RSpec/RepeatedSubjectCall` cop. ([@drcapulet])
+- Add support for `assert_true`, `assert_false`, `assert_not_equal`, `assert_not_nil`, `*_empty`, `*_predicate`, `*_kind_of`, `*_in_delta`, `*_match`, `*_instance_of` and `*_includes` assertions in `RSpec/Rails/MinitestAssertions`. ([@ydah], [@G-Rath])
+- Support asserts with messages in `RSpec/BeEmpty`. ([@G-Rath])
+- Fix a false positive for `RSpec/ExpectActual` when used with rspec-rails routing matchers. ([@naveg])
+- Add configuration option `ResponseMethods` to `RSpec/Rails/HaveHttpStatus`. ([@ydah])
+- Fix a false negative for `RSpec/DescribedClass` when class with constant. ([@ydah])
+- Fix a false positive for `RSpec/ExampleWithoutDescription` when `specify` with multi-line block and missing description. ([@ydah])
+- Fix an incorrect autocorrect for `RSpec/ChangeByZero` when compound expectations with line break before `.by(0)`. ([@ydah])
+
+## 2.26.1 (2024-01-05)
+
+- Fix an error for `RSpec/SharedExamples` when using examples without argument. ([@ydah])
+
+## 2.26.0 (2024-01-04)
+
+- Add new `RSpec/RedundantPredicateMatcher` cop. ([@ydah])
+- Add new `RSpec/RemoveConst` cop. ([@swelther])
+- Add support for correcting "it will" (future tense) for `RSpec/ExampleWording`. ([@jdufresne])
+- Add support for `symbol` style for `RSpec/SharedExamples`. ([@jessieay])
+- Ensure `PendingWithoutReason` can detect violations inside shared groups. ([@robinaugh])
+
+## 2.25.0 (2023-10-27)
+
+- Add support single quoted string and percent string and heredoc for `RSpec/Rails/HttpStatus`. ([@ydah])
+- Change to be inline disable for `RSpec/SpecFilePathFormat` like `RSpec/FilePath`. ([@ydah])
+- Fix a false positive for `RSpec/MetadataStyle` with example groups having multiple string arguments. ([@franzliedke])
+
+## 2.24.1 (2023-09-23)
+
+- Fix an error when using `RSpec/FilePath` and revert to enabled by default. If you have already moved to `RSpec/SpecFilePathSuffix` and `RSpec/SpecFilePathFormat`, disable `RSpec/FilePath` explicitly as `Enabled: false`. The `RSpec/FilePath` before migration and the `RSpec/SpecFilePathSuffix` and `RSpec/SpecFilePathFormat` as the target are available respectively. ([@ydah])
+
+## 2.24.0 (2023-09-08)
+
+- Split `RSpec/FilePath` into `RSpec/SpecFilePathSuffix` and `RSpec/SpecFilePathFormat`. `RSpec/FilePath` cop is disabled by default and the two new cops are pending and need to be enabled explicitly. ([@ydah])
+- Add new `RSpec/Eq` cop. ([@ydah])
+- Add `RSpec/MetadataStyle` and `RSpec/EmptyMetadata` cops. ([@r7kamura])
+- Add support `RSpec/Rails/HttpStatus` when `have_http_status` with string argument. ([@ydah])
+- Fix an infinite loop error when `RSpec/ExcessiveDocstringSpacing` finds a description with non-ASCII leading/trailing whitespace. ([@bcgraham])
+- Fix an incorrect autocorrect for `RSpec/ReceiveMessages` when return values declared between stubs. ([@marocchino])
+- Fix a false positive `RSpec/Focus` when chained method call and inside define method. ([@ydah])
+
+## 2.23.2 (2023-08-09)
+
+- Fix an incorrect autocorrect for `RSpec/ReceiveMessages` when method is only non-word character. ([@marocchino])
+- Fix a false positive for `RSpec/ReceiveMessages` when return with splat. ([@marocchino])
+
+## 2.23.1 (2023-08-07)
+
+- Mark to `Safe: false` for `RSpec/Rails/NegationBeValid` cop. ([@ydah])
+- Declare autocorrect as unsafe for `RSpec/ReceiveMessages`. ([@bquorning])
+
+## 2.23.0 (2023-07-30)
+
+- Add new `RSpec/Rails/NegationBeValid` cop. ([@ydah])
+- Fix a false negative for `RSpec/ExcessiveDocstringSpacing` when finds description with em space. ([@ydah])
+- Fix a false positive for `RSpec/EmptyExampleGroup` when example group with examples defined in `if` branch inside iterator. ([@ydah])
+- Update the message output of `RSpec/ExpectActual` to include the word 'value'. ([@corydiamand])
+- Fix a false negative for `RSpec/Pending` when `it` without body. ([@ydah])
+- Add new `RSpec/ReceiveMessages` cop. ([@ydah])
+- Change default.yml path to use `**/spec/*` instead of `spec/*`. ([@ydah])
+- Add `AllowedIdentifiers` and `AllowedPatterns` configuration option to `RSpec/IndexedLet`. ([@ydah])
+- Fix `RSpec/NamedSubject` when block has no body. ([@splattael])
+- Fix `RSpec/LetBeforeExamples` autocorrect incompatible with `RSpec/ScatteredLet` autocorrect. ([@ydah])
+- Update `RSpec/Focus` to support `shared_context` and `shared_examples`. ([@tmaier])
+
+## 2.22.0 (2023-05-06)
+
+- Extract factory_bot cops to a separate repository, [`rubocop-factory_bot`](https://github.com/rubocop/rubocop-factory_bot). The `rubocop-factory_bot` repository is a dependency of `rubocop-rspec` and the factory_bot cops are aliased (`RSpec/FactoryBot/Foo` == `FactoryBot/Foo`) until v3.0 is released, so the change will be invisible to users until then. ([@ydah])
+
+## 2.21.0 (2023-05-05)
+
+- Fix a false positive in `RSpec/IndexedLet` with suffixes after index-like numbers. ([@pirj])
+- Fix an error for `RSpec/Rails/HaveHttpStatus` with comparison with strings containing non-numeric characters. ([@ydah])
+- Fix an error for `RSpec/MatchArray` when `match_array` with no argument. ([@ydah])
+- Add support `a_block_changing` and `changing` for `RSpec/ChangeByZero`. ([@ydah])
+- Drop Ruby 2.6 support. ([@ydah])
+
+## 2.20.0 (2023-04-18)
+
+- Add new `RSpec/IndexedLet` cop. ([@dmitrytsepelev])
+- Add new `RSpec/BeEmpty` cop. ([@ydah], [@bquorning])
+- Add autocorrect support for `RSpec/ScatteredSetup`. ([@ydah])
+- Add support `be_status` style for `RSpec/Rails/HttpStatus`. ([@ydah])
+- Add support for shared example groups to `RSpec/EmptyLineAfterExampleGroup`. ([@pirj])
+- Add support for `RSpec/HaveHttpStatus` when using `response.code`. ([@ydah])
+- Fix order of expected and actual in correction for `RSpec/Rails/MinitestAssertions`. ([@mvz])
+- Fix a false positive for `RSpec/DescribedClassModuleWrapping` when RSpec.describe numblock is nested within a module. ([@ydah])
+- Fix a false positive for `RSpec/FactoryBot/ConsistentParenthesesStyle` inside `&&`, `||` and `:?` when `omit_parentheses` is on. ([@dmitrytsepelev])
+- Fix a false positive for `RSpec/PendingWithoutReason` when pending/skip has a reason inside an example group. ([@ydah])
+- Fix a false negative for `RSpec/RedundantAround` when redundant numblock `around`. ([@ydah])
+- Change `RSpec/ContainExactly` to ignore calls with no arguments, and change `RSpec/MatchArray` to ignore calls with an empty array literal argument. ([@ydah], [@bquorning])
+- Make `RSpec/MatchArray` and `RSpec/ContainExactly` pending. ([@ydah])
+
+## 2.19.0 (2023-03-06)
+
+- Fix a false positive for `RSpec/ContextWording` when context is interpolated string literal or execute string. ([@ydah])
+- Fix a false positive for `RSpec/DescribeMethod` when multi-line describe without `#` and `.` at the beginning. ([@ydah], [@pirj])
+- Fix a false positive for `RSpec/VariableName` when inside non-spec code. ([@ydah])
+- Fix a false positive for `RSpec/VariableDefinition` when inside non-spec code. ([@ydah])
+- Add new `RSpec/PendingBlockInsideExample` cop. ([@ydah])
+- Add `RSpec/RedundantAround` cop. ([@r7kamura])
+- Add `RSpec/Rails/TravelAround` cop. ([@r7kamura])
+- Add `RSpec/ContainExactly` and `RSpec/MatchArray` cops. ([@faucct])
+- Fix a false positive for `RSpec/PendingWithoutReason` when not inside example and pending/skip with block. ([@ydah], [@pirj])
+- Fix a false positive for `RSpec/PendingWithoutReason` when `skip` is passed a block inside example. ([@ydah], [@pirj])
+- Rename `RSpec/PendingBlockInsideExample` cop to `RSpec/SkipBlockInsideExample`. ([@pirj])
+- Deprecate `send_pattern`/`block_pattern`/`numblock_pattern` helpers in favour of using node pattern explicitly. ([@pirj], [@ydah])
+- Fix an incorrect autocorrect for `RSpec/VerifiedDoubleReference` when namespaced class. ([@ydah])
+
+## 2.18.1 (2023-01-19)
+
+- Add `rubocop-capybara` version constraint to prevent sudden cop enabling when it hits 3.0. ([@pirj])
+
+## 2.18.0 (2023-01-16)
+
+- Extract Capybara cops to a separate repository, [`rubocop-capybara`](https://github.com/rubocop/rubocop-capybara). The `rubocop-capybara` repository is a dependency of `rubocop-rspec` and the Capybara cops are aliased (`RSpec/Capybara/Foo` == `Capybara/Foo`) until v3.0 is released, so the change will be invisible to users until then. ([@pirj])
+
+## 2.17.1 (2023-01-16)
+
+- Fix a false negative for `RSpec/Pending` when using skipped in metadata is multiline string. ([@ydah])
+- Fix a false positive for `RSpec/NoExpectationExample` when using skipped in metadata is multiline string. ([@ydah])
+- Fix a false positive for `RSpec/ContextMethod` when multi-line context with `#` at the beginning. ([@ydah])
+- Fix an incorrect autocorrect for `RSpec/PredicateMatcher` when multiline expect and predicate method with heredoc. ([@ydah])
+- Fix a false positive for `RSpec/PredicateMatcher` when `include` with multiple argument. ([@ydah])
+
+## 2.17.0 (2023-01-13)
+
+- Fix a false positive for `RSpec/PendingWithoutReason` when pending/skip is argument of methods. ([@ydah])
+- Add new `RSpec/Capybara/MatchStyle` cop. ([@ydah])
+- Add new `RSpec/Rails/MinitestAssertions` cop. ([@ydah])
+- Fix a false positive for `RSpec/PendingWithoutReason` when not inside example. ([@ydah])
+- Fix a false negative for `RSpec/PredicateMatcher` when using `include` and `respond_to`. ([@ydah])
+- Fix a false positive for `RSpec/StubbedMock` when stubbed message expectation with a block and block parameter. ([@ydah])
+
+## 2.16.0 (2022-12-13)
+
+- Add new `RSpec/FactoryBot/FactoryNameStyle` cop. ([@ydah])
+- Improved processing speed for `RSpec/Be`, `RSpec/ExpectActual`, `RSpec/ImplicitExpect`, `RSpec/MessageSpies`, `RSpec/PredicateMatcher` and `RSpec/Rails/HaveHttpStatus`. ([@ydah])
+- Fix wrong autocorrection in `n_times` style on `RSpec/FactoryBot/CreateList`. ([@r7kamura])
+- Fix a false positive for `RSpec/FactoryBot/ConsistentParenthesesStyle` when using `generate` with multiple arguments. ([@ydah])
+- Mark `RSpec/BeEq` as `Safe: false`. ([@r7kamura])
+- Add `RSpec/DuplicatedMetadata` cop. ([@r7kamura])
+- Mark `RSpec/BeEql` as `Safe: false`. ([@r7kamura])
+- Add `RSpec/PendingWithoutReason` cop. ([@r7kamura])
+
+## 2.15.0 (2022-11-03)
+
+- Fix a false positive for `RSpec/RepeatedDescription` when different its block expectations are used. ([@ydah])
+- Add `named_only` style to `RSpec/NamedSubject`. ([@kuahyeow])
+- Fix `RSpec/FactoryBot/ConsistentParenthesesStyle` to ignore calls without the first positional argument. ([@pirj])
+- Fix `RSpec/FactoryBot/ConsistentParenthesesStyle` to ignore calls inside a Hash or an Array. ([@pirj])
+- Fix `RSpec/NestedGroups` to correctly use `AllowedGroups` config. ([@samrjenkins])
+- Remove `Runners` and `HookScopes` RSpec DSL elements from configuration. ([@pirj])
+- Add `with default RSpec/Language config` helper to `lib` (under `rubocop/rspec/shared_contexts/default_rspec_language_config_context`), to allow use for downstream cops based on `RuboCop::Cop::RSpec::Base`. ([@smcgivern])
+
+## 2.14.2 (2022-10-25)
+
+- Fix an incorrect autocorrect for `FactoryBot/ConsistentParenthesesStyle` with `omit_parentheses` option when method name and first argument are not on same line. ([@ydah])
+- Fix autocorrection loop in `RSpec/ExampleWording` for insufficient example wording. ([@pirj])
+- Fix `RSpec/SortMetadata` not to reorder arguments of `include_`/`it_behaves_like`. ([@pirj])
+- Fix a false positive for `RSpec/NoExpectationExample` when allowed pattern methods with arguments. ([@ydah])
+- Change `RSpec/FilePath` so that it only checks suffix when path is under spec/routing or type is defined as routing. ([@r7kamura])
+
+## 2.14.1 (2022-10-24)
+
+- Fix an error for `RSpec/Rails/InferredSpecType` with redundant type before other Hash metadata. ([@ydah])
+
+## 2.14.0 (2022-10-23)
+
+- Add `require_implicit` style to `RSpec/ImplicitSubject`. ([@r7kamura])
+- Fix a false positive for `RSpec/Capybara/SpecificMatcher` when `have_css("a")` without attribute. ([@ydah])
+- Update `RSpec/ExampleWording` cop to raise error for insufficient descriptions. ([@akrox58])
+- Add new `RSpec/Capybara/NegationMatcher` cop. ([@ydah])
+- Add `AllowedPatterns` configuration option to `RSpec/NoExpectationExample`. ([@ydah])
+- Improve `RSpec/NoExpectationExample` cop to ignore examples skipped or pending via metadata. ([@pirj])
+- Add `RSpec/FactoryBot/ConsistentParenthesesStyle` cop. ([@Liberatys])
+- Add `RSpec/Rails/InferredSpecType` cop. ([@r7kamura])
+- Add new `RSpec/Capybara/SpecificActions` cop. ([@ydah])
+- Update `config/default.yml` removing deprecated option to make the config correctable by users. ([@ignaciovillaverde])
+- Do not attempt to auto-correct example groups with `include_examples` in `RSpec/LetBeforeExamples`. ([@pirj])
+- Add new `RSpec/SortMetadata` cop. ([@leoarnold])
+- Add support for subject! method to `RSpec/SubjectDeclaration`. ([@ydah])
+
+## 2.13.2 (2022-09-23)
+
+- Fix an error for `RSpec/Capybara/SpecificFinders` with no parentheses. ([@ydah])
+- Fix a false positive for `RSpec/NoExpectationExample` with pending using `skip` or `pending` inside an example. ([@ydah])
+- Exclude `have_text` and `have_content` that raise `ArgumentError` with `RSpec/Capybara/VisibilityMatcher` where `:visible` is an invalid option. ([@ydah])
+- Fix a false negative for `RSpec/Capybara/VisibilityMatcher` with negative matchers. ([@ydah])
+
+## 2.13.1 (2022-09-12)
+
+- Include config/obsoletion.yml in the gemspec. ([@hosamaly])
+
+## 2.13.0 (2022-09-12)
+
+- Fix `RSpec/FilePath` cop missing mismatched expanded namespace. ([@sl4vr])
+- Add new `AllowConsecutiveOneLiners` (default true) option for `RSpec/EmptyLineAfterHook` cop. ([@ngouy])
+- Add autocorrect support for `RSpec/EmptyExampleGroup`. ([@r7kamura])
+- Fix `RSpec/ChangeByZero` with compound expressions using `&` or `|` operators. ([@BrianHawley])
+- Add `RSpec/NoExpectationExample`. ([@r7kamura])
+- Add some expectation methods to default configuration. ([@r7kamura])
+- Fix a false positive for `RSpec/Capybara/SpecificMatcher`. ([@ydah])
+- Fix a false negative for `RSpec/Capybara/SpecificMatcher` for `have_field`. ([@ydah])
+- Fix a false positive for `RSpec/Capybara/SpecificMatcher` when may not have a `href` by `have_link`. ([@ydah])
+- Add `NegatedMatcher` configuration option to `RSpec/ChangeByZero`. ([@ydah])
+- Add new `RSpec/Capybara/SpecificFinders` cop. ([@ydah])
+- Add support for numblocks to `RSpec/AroundBlock`, `RSpec/EmptyLineAfterHook`, `RSpec/ExpectInHook`, `RSpec/HookArgument`, `RSpec/HooksBeforeExamples`, `RSpec/IteratedExpectation`, and `RSpec/NoExpectationExample`. ([@ydah])
+- Fix incorrect documentation URLs when using `rubocop --show-docs-url`. ([@r7kamura])
+- Add `AllowedGroups` configuration option to `RSpec/NestedGroups`. ([@ydah])
+- Deprecate `IgnoredPatterns` option in favor of the `AllowedPatterns` options. ([@ydah])
+- Add `AllowedPatterns` configuration option to `RSpec/ContextWording`. ([@ydah])
+- Add `RSpec/ClassCheck` cop. ([@r7kamura])
+- Fix a false positive for `RSpec/Capybara/SpecificMatcher` when pseudo-classes. ([@ydah])
+- Fix a false negative for `RSpec/SubjectStub` when the subject is declared with the `subject!` method and called by name. ([@eikes])
+- Support `Array.new(n)` on `RSpec/FactoryBot/CreateList` cop. ([@r7kamura])
+
+## 2.12.1 (2022-07-03)
+
+- Fix a false positive for `RSpec/Capybara/SpecificMatcher`. ([@ydah])
+
+## 2.12.0 (2022-07-02)
+
+- Fix incorrect path suggested by `RSpec/FilePath` cop when second argument contains spaces. ([@tejasbubane])
+- Fix autocorrect for EmptyLineSeparation. ([@johnny-miyake])
+- Add new `RSpec/Capybara/SpecificMatcher` cop. ([@ydah])
+- Fixed false offense detection in `FactoryBot/CreateList` when a n.times block is including method calls in the factory create arguments. ([@ngouy])
+- Fix error in `RSpec/RSpec/FactoryBot/CreateList` cop for empty block. ([@tejasbubane])
+- Update `RSpec/MultipleExpectations` cop documentation with examples of aggregate_failures use. ([@edgibbs])
+- Declare autocorrect as unsafe for `RSpec/VerifiedDoubleReference`. ([@Drowze])
+- Add new `RSpec/Rails/HaveHttpStatus` cop. ([@akiomik])
+
+## 2.11.1 (2022-05-18)
+
+- Fix a regression in `RSpec/ExpectChange` flagging chained method calls. ([@pirj])
+
+## 2.11.0 (2022-05-18)
+
+- Drop Ruby 2.5 support. ([@ydah])
+- Add new `RSpec/ChangeByZero` cop. ([@ydah])
+- Improve `RSpec/ExpectChange` to detect namespaced and top-level constants. ([@M-Yamashita01])
+- Introduce an amendment to `Metrics/BlockLength` to exclude spec files. ([@luke-hill])
+
+## 2.10.0 (2022-04-19)
+
+- Fix a false positive for `RSpec/EmptyExampleGroup` when expectations in case statement. ([@ydah])
+- Add `RSpec/VerifiedDoubleReference` cop. ([@t3h2mas])
+- Make `RSpec/BeNil` cop configurable with a `be_nil` style and a `be` style. ([@bquorning])
+- Fix `Capybara/CurrentPathExpectation` autocorrect incompatible with `Style/TrailingCommaInArguments` autocorrect. ([@ydah])
+
+## 2.9.0 (2022-02-28)
+
+- Add new `RSpec/BeNil` cop. ([@bquorning])
+- Add new `RSpec/BeEq` cop. ([@bquorning])
+
+## 2.8.0 (2022-01-24)
+
+- Fix `RSpec/FactoryBot/SyntaxMethods` and `RSpec/Capybara/FeatureMethods` to inspect shared groups. ([@pirj])
+- Fix `RSpec/LeadingSubject` failure in non-spec code. ([@pirj])
+- Add bad example to `RSpec/SubjectStub` cop. ([@oshiro3])
+- Replace non-styleguide cops `StyleGuide` attribute with `Reference`. ([@pirj])
+- Fix `RSpec/SubjectStub` to disallow stubbing of subjects defined in parent example groups. ([@pirj])
+
+## 2.7.0 (2021-12-26)
+
+- Add new `RSpec/FactoryBot/SyntaxMethods` cop. ([@leoarnold])
+- Exclude `task` type specs from `RSpec/DescribeClass` cop. ([@harry-graham])
+
+## 2.6.0 (2021-11-08)
+
+- Fix merging RSpec DSL configuration from third-party gems. ([@pirj])
+- Fix `RSpec/ExcessiveDocstringSpacing` false positive for multi-line indented strings. ([@G-Rath])
+- Fix `Include` configuration for sub-departments. ([@pirj])
+- Ignore heredocs in `RSpec/ExcessiveDocstringSpacing`. ([@G-Rath])
+- Stop `RSpec/ExampleWording` from trying to correct heredocs. ([@G-Rath])
+- Add autocorrect support for `RSpec/VariableDefinition`. ([@r7kamura])
+
+## 2.5.0 (2021-09-21)
+
+- Declare autocorrect as unsafe for `ExpectChange`. ([@francois-ferrandis])
+- Fix each example for `RSpec/HookArgument`. ([@lokhi])
+- Exclude unrelated Rails directories from `RSpec/DescribeClass`. ([@MothOnMars])
+- Add `RSpec/ExcessiveDocstringSpacing` cop. ([@G-Rath])
+- Add `RSpec/SubjectDeclaration` cop. ([@dswij])
+- Fix excessive whitespace removal in `RSpec/EmptyHook` autocorrection. ([@pirj])
+- Bump RuboCop requirement to v1.19.0. ([@pirj])
+- Fix false positive in `RSpec/IteratedExpectation` when there is single, non-expectation statement in the block body. ([@Darhazer])
+
+## 2.4.0 (2021-06-09)
+
+- Update `RSpec/FilePath` to check suffix when given a non-constant top-level node (e.g. features). ([@topalovic])
+- Add missing documentation for `single_statement_only` style of `RSpec/ImplicitSubject` cop. ([@tejasbubane])
+- Fix an exception in `DescribedClass` when accessing a constant on a variable in a spec that is nested in a namespace. ([@rrosenblum])
+- Add new `RSpec/IdenticalEqualityAssertion` cop. ([@tejasbubane])
+- Add `RSpec/Rails/AvoidSetupHook` cop. ([@paydaylight])
+- Fix false negative in `RSpec/ExpectChange` cop with block style and chained method call. ([@tejasbubane])
+
+## 2.3.0 (2021-04-28)
+
+- Allow `RSpec/ContextWording` to accept multi-word prefixes. ([@hosamaly])
+- Drop support for ruby 2.4. ([@bquorning])
+- Add `CountAsOne` configuration option to `RSpec/ExampleLength`. ([@stephannv])
+- Fix a false positive for `RSpec/RepeatedExampleGroupBody` when `pending` or `skip` have argument(s). ([@Tietew])
+
+## 2.2.0 (2021-02-02)
+
+- Fix `HooksBeforeExamples`, `LeadingSubject`, `LetBeforeExamples` and `ScatteredLet` autocorrection to take into account inline comments and comments immediately before the moved node. ([@Darhazer])
+- Improve rubocop-rspec performance. ([@Darhazer], [@bquorning])
+- Include `Enabled: true` to prevent a mismatched configuration parameter warning when `RSpec` cops are explicitly enabled in the user configuration. ([@pirj])
+
+## 2.1.0 (2020-12-17)
+
+- Fix `RSpec/FilePath` false positive for relative file path runs with long namespaces. ([@ahukkanen])
+- Update `RSpec/Focus` to have auto-correction. ([@dvandersluis])
+
+## 2.0.1 (2020-12-02)
+
+- Fixed infinite loop in `RSpec/ExpectActual` autocorrection when both expected and actual values are literals. ([@Darhazer])
+
+## 2.0.0 (2020-11-06)
+
+- Remove deprecated class `::RuboCop::Cop::RSpec::Cop`. ([@bquorning])
+- Retire `RSpec/InvalidPredicateMatcher` cop. ([@pirj])
+- Remove the code responsible for filtering files to inspect. ([@pirj])
+- Make RSpec language elements configurable. ([@sl4vr])
+- Remove `CustomIncludeMethods` `RSpec/EmptyExampleGroup` option in favour of the new RSpec DSL configuration. ([@pirj])
+- Enabled pending cop (`RSpec/StubbedMock`). ([@pirj])
+
+## 2.0.0.pre (2020-10-22)
+
+- Update RuboCop dependency to v1.0.0. ([@bquorning])
+- Change namespace of several cops (`Capybara/*` -> `RSpec/Capybara/*`, `FactoryBot/*` -> `RSpec/FactoryBot/*`, `Rails/*` -> `RSpec/Rails/*`). ([@pirj], [@bquorning])
+
+## 1.44.1 (2020-10-20)
+
+- Relax `rubocop-ast` version constraint. ([@PhilCoggins])
+
+## 1.44.0 (2020-10-20)
+
+- Move our documentation from rubocop-rspec.readthedocs.io to docs.rubocop.org/rubocop-rspec. ([@bquorning])
+- Add `RSpec/RepeatedIncludeExample` cop. ([@biinari])
+- Add `RSpec/StubbedMock` cop. ([@bquorning], [@pirj])
+- Add `IgnoredMetadata` configuration option to `RSpec/DescribeClass`. ([@Rafix02])
+- Fix false positives in `RSpec/EmptyExampleGroup`. ([@pirj])
+- Fix a false positive for `RSpec/EmptyExampleGroup` when example is defined in an `if` branch. ([@koic])
+
+## 1.43.2 (2020-08-25)
+
+- Fix `RSpec/FilePath` when checking a file with a shared example. ([@pirj])
+- Fix subject nesting detection in `RSpec/LeadingSubject`. ([@pirj])
+
+## 1.43.1 (2020-08-17)
+
+- Fix `RSpec/FilePath` when checking a file defining e.g. an empty class. ([@bquorning])
+
+## 1.43.0 (2020-08-17)
+
+- Add a new base cop class `::RuboCop::Cop::RSpec::Base`. The old base class `::RuboCop::Cop::RSpec::Cop` is deprecated, and will be removed in the next major release. ([@bquorning])
+- Add support for subject detection after includes and example groups in `RSpec/LeadingSubject`. ([@pirj])
+- Ignore trailing punctuation in context description prefix. ([@elliterate])
+- Relax `RSpec/VariableDefinition` cop so interpolated and multiline strings are accepted even when configured to enforce the `symbol` style. ([@bquorning])
+- Fix `RSpec/EmptyExampleGroup` to flag example groups with examples in invalid scopes. ([@mlarraz])
+- Fix `RSpec/EmptyExampleGroup` to ignore examples groups with examples defined inside iterators. ([@pirj])
+- Improve `RSpec/NestedGroups`, `RSpec/FilePath`, `RSpec/DescribeMethod`, `RSpec/MultipleDescribes`, `RSpec/DescribeClass`'s top-level example group detection. ([@pirj])
+- Add detection of `let!` with a block-pass or a string literal to `RSpec/LetSetup`. ([@pirj])
+- Add `IgnoredPatterns` configuration option to `RSpec/VariableName`. ([@jtannas])
+- Add `RSpec/MultipleMemoizedHelpers` cop. ([@mockdeep])
+
+## 1.42.0 (2020-07-09)
+
+- Update RuboCop dependency to 0.87.0 because of changes to internal APIs. ([@bquorning], [@Darhazer])
+
+## 1.41.0 (2020-07-03)
+
+- Extend the list of Rails spec types for `RSpec/DescribeClass`. ([@pirj])
+- Fix `FactoryBot/AttributeDefinedStatically` to allow `#traits_for_enum` without a block. ([@harrylewis])
+- Improve the performance of `FactoryBot/AttributeDefinedStatically`, `RSpec/InstanceVariable`, `RSpec/LetSetup`, `RSpec/NestedGroups` and `RSpec/ReturnFromStub`. ([@andrykonchin])
+
+## 1.40.0 (2020-06-11)
+
+- Add new `RSpec/VariableName` cop. ([@tejasbubane])
+- Add new `RSpec/VariableDefinition` cop. ([@tejasbubane])
+- Expand `Capybara/VisibilityMatcher` to support more than just `have_selector`. ([@twalpole])
+- Add new `SpecSuffixOnly` option to `RSpec/FilePath` cop. ([@zdennis])
+- Allow `RSpec/RepeatedExampleGroupBody` to differ only by described_class. ([@robotdana])
+- Fix `RSpec/FilePath` detection across sibling directories. ([@rolfschmidt])
+- Improve the performance of `RSpec/SubjectStub` by an order of magnitude. ([@andrykonchin])
+
+## 1.39.0 (2020-05-01)
+
+- Fix `RSpec/FilePath` detection when absolute path includes test subject. ([@eitoball])
+- Add new `Capybara/VisibilityMatcher` cop. ([@aried3r])
+- Ignore String constants by `RSpec/Describe`. ([@AlexWayfer])
+- Drop support for ruby 2.3. ([@bquorning])
+- Fix multiple cops to detect `let` with proc argument. ([@tejasbubane])
+- Add autocorrect support for `RSpec/ScatteredLet`. ([@Darhazer])
+- Add new `RSpec/EmptyHook` cop. ([@tejasbubane])
+
 ## 1.38.1 (2020-02-15)
 
-* Fix `RSpec/RepeatedDescription` to detect descriptions with interpolation and methods. ([@lazycoder9][])
+- Fix `RSpec/RepeatedDescription` to detect descriptions with interpolation and methods. ([@lazycoder9])
 
 ## 1.38.0 (2020-02-11)
 
-* Fix `RSpec/InstanceVariable` detection inside custom matchers. ([@pirj][])
-* Fix `RSpec/ScatteredSetup` to distinguish hooks with different metadata. ([@pirj][])
-* Add autocorrect support for `RSpec/ExpectActual` cop. ([@dduugg][], [@pirj][])
-* Add `RSpec/RepeatedExampleGroupBody` cop. ([@lazycoder9][])
-* Add `RSpec/RepeatedExampleGroupDescription` cop. ([@lazycoder9][])
-* Add block name and other lines to `RSpec/ScatteredSetup` message. ([@elebow][])
-* Fix `RSpec/RepeatedDescription` to take into account example metadata. ([@lazycoder9][])
+- Fix `RSpec/InstanceVariable` detection inside custom matchers. ([@pirj])
+- Fix `RSpec/ScatteredSetup` to distinguish hooks with different metadata. ([@pirj])
+- Add autocorrect support for `RSpec/ExpectActual` cop. ([@dduugg], [@pirj])
+- Add `RSpec/RepeatedExampleGroupBody` cop. ([@lazycoder9])
+- Add `RSpec/RepeatedExampleGroupDescription` cop. ([@lazycoder9])
+- Add block name and other lines to `RSpec/ScatteredSetup` message. ([@elebow])
+- Fix `RSpec/RepeatedDescription` to take into account example metadata. ([@lazycoder9])
 
 ## 1.37.1 (2019-12-16)
 
-* Improve message and description of `FactoryBot/FactoryClassName`. ([@ybiquitous][])
-* Fix `FactoryBot/FactoryClassName` to ignore `Hash` and `OpenStruct`. ([@jfragoulis][])
+- Improve message and description of `FactoryBot/FactoryClassName`. ([@ybiquitous])
+- Fix `FactoryBot/FactoryClassName` to ignore `Hash` and `OpenStruct`. ([@jfragoulis])
 
 ## 1.37.0 (2019-11-25)
 
-* Implement `RSpec/DescribedClassModuleWrapping` to disallow RSpec statements within a module. ([@kellysutton][])
-* Fix documentation rake task to support Rubocop 0.75. ([@nickcampbell18][])
-* Fix `RSpec/SubjectStub` to detect implicit subjects stubbed. ([@QQism][])
-* Fix `RSpec/Pending` not flagging `skip` with string values. ([@pirj][])
-* Add `AllowedExplicitMatchers` config option for `RSpec/PredicateMatcher`. ([@mkrawc][])
-* Add `FactoryBot/FactoryClassName` cop. ([@jfragoulis][])
+- Implement `RSpec/DescribedClassModuleWrapping` to disallow RSpec statements within a module. ([@kellysutton])
+- Fix documentation rake task to support RuboCop 0.75. ([@nickcampbell18])
+- Fix `RSpec/SubjectStub` to detect implicit subjects stubbed. ([@QQism])
+- Fix `RSpec/Pending` not flagging `skip` with string values. ([@pirj])
+- Add `AllowedExplicitMatchers` config option for `RSpec/PredicateMatcher`. ([@mkrawc])
+- Add `FactoryBot/FactoryClassName` cop. ([@jfragoulis])
 
 ## 1.36.0 (2019-09-27)
 
-* Fix `RSpec/DescribedClass`'s error when `described_class` is used as part of a constant. ([@pirj][])
-* Fix `RSpec/ExampleWording` autocorrect of multi-line docstrings. ([@pirj][])
-* Add `RSpec/ContextMethod` cop, to detect method names in `context`. ([@geniou][])
-* Update RuboCop dependency to 0.68.1 with support for children matching node pattern syntax. ([@pirj][])
-* Add `RSpec/EmptyLineAfterExample` cop to check that there is an empty line after example blocks. ([@pirj][])
-* Fix `Capybara/CurrentPathExpectation` auto-corrector, to include option `ignore_query: true`. ([@onumis][])
-* Fix `RSpec/Focus` detecting mixed array/hash metadata. ([@dgollahon][])
-* Fix `RSpec/Focus` to also detect `pending` examples. ([@dgollahon][])
+- Fix `RSpec/DescribedClass`'s error when `described_class` is used as part of a constant. ([@pirj])
+- Fix `RSpec/ExampleWording` autocorrect of multi-line docstrings. ([@pirj])
+- Add `RSpec/ContextMethod` cop, to detect method names in `context`. ([@geniou])
+- Update RuboCop dependency to 0.68.1 with support for children matching node pattern syntax. ([@pirj])
+- Add `RSpec/EmptyLineAfterExample` cop to check that there is an empty line after example blocks. ([@pirj])
+- Fix `Capybara/CurrentPathExpectation` auto-corrector, to include option `ignore_query: true`. ([@onumis])
+- Fix `RSpec/Focus` detecting mixed array/hash metadata. ([@dgollahon])
+- Fix `RSpec/Focus` to also detect `pending` examples. ([@dgollahon])
 
 ## 1.35.0 (2019-08-02)
 
-* Add `RSpec/ImplicitBlockExpectation` cop. ([@pirj][])
+- Add `RSpec/ImplicitBlockExpectation` cop. ([@pirj])
 
 ## 1.34.1 (2019-07-31)
 
-* Fix `RSpec/DescribedClass`'s error when a local variable is part of the namespace. ([@pirj][])
+- Fix `RSpec/DescribedClass`'s error when a local variable is part of the namespace. ([@pirj])
 
 ## 1.34.0 (2019-07-23)
 
-* Remove `AggregateFailuresByDefault` config option of `RSpec/MultipleExpectations`. ([@pirj][])
-* Add `RSpec/LeakyConstantDeclaration` cop. ([@jonatas][], [@pirj][])
-* Improve `aggregate_failures` metadata detection of `RSpec/MultipleExpectations`. ([@pirj][])
-* Improve `RSpec/SubjectStub` detection and message. ([@pirj][])
-* Change message of `RSpec/LetSetup` cop to be more descriptive. ([@foton][])
-* Improve `RSpec/ExampleWording` to handle interpolated example messages. ([@nc-holodakg][])
-* Improve detection by allowing the use of `RSpec` as a top-level constant. ([@pirj][])
-* Fix `RSpec/DescribedClass`'s incorrect detection. ([@pirj][])
-* Improve `RSpec/DescribedClass`'s ability to detect inside modules and classes. ([@pirj][])
+- Remove `AggregateFailuresByDefault` config option of `RSpec/MultipleExpectations`. ([@pirj])
+- Add `RSpec/LeakyConstantDeclaration` cop. ([@jonatas], [@pirj])
+- Improve `aggregate_failures` metadata detection of `RSpec/MultipleExpectations`. ([@pirj])
+- Improve `RSpec/SubjectStub` detection and message. ([@pirj])
+- Change message of `RSpec/LetSetup` cop to be more descriptive. ([@foton])
+- Improve `RSpec/ExampleWording` to handle interpolated example messages. ([@nc-holodakg])
+- Improve detection by allowing the use of `RSpec` as a top-level constant. ([@pirj])
+- Fix `RSpec/DescribedClass`'s incorrect detection. ([@pirj])
+- Improve `RSpec/DescribedClass`'s ability to detect inside modules and classes. ([@pirj])
 
 ## 1.33.0 (2019-05-13)
 
-* Let `RSpec/DescribedClass` pass `Struct` instantiation closures. ([@schmijos][])
-* Fixed `RSpec/ContextWording` missing `context`s with metadata. ([@pirj][])
-* Fix `FactoryBot/AttributeDefinedStatically` not working with an explicit receiver. ([@composerinteralia][])
-* Add `RSpec/Dialect` enforces custom RSpec dialects. ([@gsamokovarov][])
-* Fix redundant blank lines in `RSpec/MultipleSubjects`'s autocorrect. ([@pirj][])
-* Drop support for ruby `2.2`. ([@bquorning][])
+- Let `RSpec/DescribedClass` pass `Struct` instantiation closures. ([@schmijos])
+- Fixed `RSpec/ContextWording` missing `context`s with metadata. ([@pirj])
+- Fix `FactoryBot/AttributeDefinedStatically` not working with an explicit receiver. ([@composerinteralia])
+- Add `RSpec/Dialect` enforces custom RSpec dialects. ([@gsamokovarov])
+- Fix redundant blank lines in `RSpec/MultipleSubjects`'s autocorrect. ([@pirj])
+- Drop support for ruby `2.2`. ([@bquorning])
 
 ## 1.32.0 (2019-01-27)
 
-* Add `RSpec/Yield` cop, suggesting using the `and_yield` method when stubbing a method, accepting a block. ([@Darhazer][])
-* Fix `FactoryBot/CreateList` autocorrect crashing when the factory is called with a block=. ([@Darhazer][])
-* Fixed `RSpec/Focus` not flagging some cases of `RSpec.describe` with `focus: true`. ([@Darhazer][])
-* Fixed `RSpec/Pending` not flagging some cases of `RSpec.describe` with `:skip`. ([@Darhazer][])
-* Fix false positive in `RSpec/ReceiveCounts` when method name `exactly`, `at_least` or `at_most` is used along with `times`, without being an RSpec API. ([@Darhazer][])
+- Add `RSpec/Yield` cop, suggesting using the `and_yield` method when stubbing a method, accepting a block. ([@Darhazer])
+- Fix `FactoryBot/CreateList` autocorrect crashing when the factory is called with a block=. ([@Darhazer])
+- Fixed `RSpec/Focus` not flagging some cases of `RSpec.describe` with `focus: true`. ([@Darhazer])
+- Fixed `RSpec/Pending` not flagging some cases of `RSpec.describe` with `:skip`. ([@Darhazer])
+- Fix false positive in `RSpec/ReceiveCounts` when method name `exactly`, `at_least` or `at_most` is used along with `times`, without being an RSpec API. ([@Darhazer])
 
 ## 1.31.0 (2019-01-02)
 
-* Add `IgnoreSharedExamples` option for `RSpec/NamedSubject`. ([@RST-J][])
-* Add autocorrect support for `Capybara/CurrentPathExpectation` cop. ([@ypresto][])
-* Add support for built-in `exists` matcher for `RSpec/PredicateMatcher` cop. ([@mkenyon][])
-* `SingleArgumentMessageChain` no longer reports an array as it's only argument as an offense. ([@Darhazer][])
+- Add `IgnoreSharedExamples` option for `RSpec/NamedSubject`. ([@RST-J])
+- Add autocorrect support for `Capybara/CurrentPathExpectation` cop. ([@ypresto])
+- Add support for built-in `exists` matcher for `RSpec/PredicateMatcher` cop. ([@mkenyon])
+- `SingleArgumentMessageChain` no longer reports an array as it's only argument as an offense. ([@Darhazer])
 
 ## 1.30.1 (2018-11-01)
 
-* `FactoryBot/CreateList` now ignores `times` blocks with an argument. ([@Darhazer][])
+- `FactoryBot/CreateList` now ignores `times` blocks with an argument. ([@Darhazer])
 
 ## 1.30.0 (2018-10-08)
 
-* Add config to `RSpec/VerifiedDoubles` to enforcement of verification on unnamed doubles. ([@BrentWheeldon][])
-* Fix `FactoryBot/AttributeDefinedStatically` not working when there is a non-symbol key. ([@vzvu3k6k][])
-* Fix false positive in `RSpec/ImplicitSubject` when `is_expected` is used inside `its()` block. ([@Darhazer][])
-* Add `single_statement_only` style to  `RSpec/ImplicitSubject` as a more relaxed alternative to `single_line_only`. ([@Darhazer][])
-* Add `RSpec/UnspecifiedException` as a default cop to encourage more-specific `expect{}.to raise_error(ExceptionType)`, or `raise_exception` style handling of exceptions. ([@daveworth][])
+- Add config to `RSpec/VerifiedDoubles` to enforcement of verification on unnamed doubles. ([@BrentWheeldon])
+- Fix `FactoryBot/AttributeDefinedStatically` not working when there is a non-symbol key. ([@vzvu3k6k])
+- Fix false positive in `RSpec/ImplicitSubject` when `is_expected` is used inside `its()` block. ([@Darhazer])
+- Add `single_statement_only` style to `RSpec/ImplicitSubject` as a more relaxed alternative to `single_line_only`. ([@Darhazer])
+- Add `RSpec/UnspecifiedException` as a default cop to encourage more-specific `expect{}.to raise_error(ExceptionType)`, or `raise_exception` style handling of exceptions. ([@daveworth])
 
 ## 1.29.1 (2018-09-01)
 
-* Fix false negative in `FactoryBot/AttributeDefinedStatically` when attribute is defined on `self`. ([@Darhazer][])
-* `RSpec/FactoryBot` cops will now also inspect the `spec/factories.rb` path by default. ([@bquorning][])
+- Fix false negative in `FactoryBot/AttributeDefinedStatically` when attribute is defined on `self`. ([@Darhazer])
+- `RSpec/FactoryBot` cops will now also inspect the `spec/factories.rb` path by default. ([@bquorning])
 
 ## 1.29.0 (2018-08-25)
 
-* `RSpec/InstanceVariable` - Recommend local variables in addition to `let`. ([@jaredbeck][])
-* Add `RSpec/ImplicitSubject` cop. ([@Darhazer][])
-* Add `RSpec/HooksBeforeExamples` cop. ([@Darhazer][])
+- `RSpec/InstanceVariable` - Recommend local variables in addition to `let`. ([@jaredbeck])
+- Add `RSpec/ImplicitSubject` cop. ([@Darhazer])
+- Add `RSpec/HooksBeforeExamples` cop. ([@Darhazer])
 
 ## 1.28.0 (2018-08-14)
 
-* Add `RSpec/ReceiveNever` cop enforcing usage of `not_to receive` instead of `never` matcher. ([@Darhazer][])
-* Fix false positive in `RSpec/EmptyLineAfterExampleGroup` cop when example is inside `if`. ([@Darhazer][])
-* Add `RSpec/MissingExampleGroupArgument` to enforce first argument for an example group. ([@geniou][])
-* Drop support for ruby `2.1`. ([@bquorning][])
-* Add `FactoryBot/AttributeDefinedStatically` cop to help FactoryBot users with the deprecation of static attributes. ([@composerinteralia][], [@seanpdoyle][])
-* Remove `FactoryBot/DynamicAttributeDefinedStatically` and `FactoryBot/StaticAttributeDefinedDynamically` cops. ([@composerinteralia][])
+- Add `RSpec/ReceiveNever` cop enforcing usage of `not_to receive` instead of `never` matcher. ([@Darhazer])
+- Fix false positive in `RSpec/EmptyLineAfterExampleGroup` cop when example is inside `if`. ([@Darhazer])
+- Add `RSpec/MissingExampleGroupArgument` to enforce first argument for an example group. ([@geniou])
+- Drop support for ruby `2.1`. ([@bquorning])
+- Add `FactoryBot/AttributeDefinedStatically` cop to help FactoryBot users with the deprecation of static attributes. ([@composerinteralia], [@seanpdoyle])
+- Remove `FactoryBot/DynamicAttributeDefinedStatically` and `FactoryBot/StaticAttributeDefinedDynamically` cops. ([@composerinteralia])
 
 ## 1.27.0 (2018-06-14)
 
-* `RSpec/LeadingSubject` now enforces subject to be before any examples, hooks or let declarations. ([@Darhazer][])
-* Fix `RSpec/NotToNot` to highlight only the selector (`not_to` or `to_not`), so it works also on `expect { ... }` blocks. ([@bquorning][])
-* Add `RSpec/EmptyLineAfterHook` cop. ([@bquorning][])
-* Add `RSpec/EmptyLineAfterExampleGroup` cop to check that there is an empty line after example group blocks. ([@bquorning][])
-* Fix `RSpec/DescribeClass` crashing on `RSpec.describe` without arguments. ([@Darhazer][])
-* Bump RuboCop requirement to v0.56.0. ([@bquorning][])
-* Fix `RSpec/OverwritingSetup` crashing if a variable is used as an argument for `let`. ([@Darhazer][])
+- `RSpec/LeadingSubject` now enforces subject to be before any examples, hooks or let declarations. ([@Darhazer])
+- Fix `RSpec/NotToNot` to highlight only the selector (`not_to` or `to_not`), so it works also on `expect { ... }` blocks. ([@bquorning])
+- Add `RSpec/EmptyLineAfterHook` cop. ([@bquorning])
+- Add `RSpec/EmptyLineAfterExampleGroup` cop to check that there is an empty line after example group blocks. ([@bquorning])
+- Fix `RSpec/DescribeClass` crashing on `RSpec.describe` without arguments. ([@Darhazer])
+- Bump RuboCop requirement to v0.56.0. ([@bquorning])
+- Fix `RSpec/OverwritingSetup` crashing if a variable is used as an argument for `let`. ([@Darhazer])
 
 ## 1.26.0 (2018-06-06)
 
-* Fix false positive in `RSpec/EmptyExampleGroup` cop when methods named like a RSpec method are used.  ([@Darhazer][])
-* Fix `Capybara/FeatureMethods` not working when there is require before the spec. ([@Darhazer][])
-* Fix `RSpec/EmptyLineAfterFinalLet`: allow a comment to be placed after latest let, requiring empty line after the comment. ([@Darhazer][])
-* Add `RSpec/ReceiveCounts` cop to enforce usage of :once and :twice matchers. ([@Darhazer][])
+- Fix false positive in `RSpec/EmptyExampleGroup` cop when methods named like a RSpec method are used. ([@Darhazer])
+- Fix `Capybara/FeatureMethods` not working when there is require before the spec. ([@Darhazer])
+- Fix `RSpec/EmptyLineAfterFinalLet`: allow a comment to be placed after latest let, requiring empty line after the comment. ([@Darhazer])
+- Add `RSpec/ReceiveCounts` cop to enforce usage of :once and :twice matchers. ([@Darhazer])
 
 ## 1.25.1 (2018-04-10)
 
-* Fix false positive in `RSpec/Pending` cop when pending is used as a method name.  ([@Darhazer][])
-* Fix `FactoryBot/DynamicAttributeDefinedStatically` false positive when using symbol proc argument for a sequence. ([@tdeo][])
+- Fix false positive in `RSpec/Pending` cop when pending is used as a method name. ([@Darhazer])
+- Fix `FactoryBot/DynamicAttributeDefinedStatically` false positive when using symbol proc argument for a sequence. ([@tdeo])
 
 ## 1.25.0 (2018-04-07)
 
-* Add `RSpec/SharedExamples` cop to enforce consistent usage of string to titleize shared examples. ([@anthony-robin][])
-* Add `RSpec/Be` cop to enforce passing argument to the generic `be` matcher. ([@Darhazer][])
-* Fix false positives in `StaticAttributeDefinedDynamically` and `ReturnFromStub` when a const is used in an array or hash. ([@Darhazer][])
-* Add `RSpec/Pending` cop to enforce no existing pending or skipped examples.  This is disabled by default. ([@patrickomatic][])
-* Fix `RSpec/NestedGroups` cop support --auto-gen-config. ([@walf443][])
-* Fix false positives in `Capybara/FeatureMethods` when feature methods are used as property names in a factory. ([@Darhazer][])
-* Allow configuring enabled methods in `Capybara/FeatureMethods`. ([@Darhazer][])
-* Add `FactoryBot/CreateList` cop. ([@Darhazer][])
+- Add `RSpec/SharedExamples` cop to enforce consistent usage of string to titleize shared examples. ([@anthony-robin])
+- Add `RSpec/Be` cop to enforce passing argument to the generic `be` matcher. ([@Darhazer])
+- Fix false positives in `StaticAttributeDefinedDynamically` and `ReturnFromStub` when a const is used in an array or hash. ([@Darhazer])
+- Add `RSpec/Pending` cop to enforce no existing pending or skipped examples. This is disabled by default. ([@patrickomatic])
+- Fix `RSpec/NestedGroups` cop support --auto-gen-config. ([@walf443])
+- Fix false positives in `Capybara/FeatureMethods` when feature methods are used as property names in a factory. ([@Darhazer])
+- Allow configuring enabled methods in `Capybara/FeatureMethods`. ([@Darhazer])
+- Add `FactoryBot/CreateList` cop. ([@Darhazer])
 
 ## 1.24.0 (2018-03-06)
 
-* Compatibility with RuboCop v0.53.0. ([@bquorning][])
-* The `Rails/HttpStatus` cop is unavailable if the `rack` gem cannot be loaded. ([@bquorning][])
-* Fix `Rails/HttpStatus` not working with custom HTTP status codes. ([@bquorning][])
-* Fix `FactoryBot/StaticAttributeDefinedDynamically` to handle empty block. ([@abrom][])
-* Fix false positive in `FactoryBot/DynamicAttributeDefinedStatically` when a before/after callback has a symbol proc argument. ([@abrom][])
+- Compatibility with RuboCop v0.53.0. ([@bquorning])
+- The `Rails/HttpStatus` cop is unavailable if the `rack` gem cannot be loaded. ([@bquorning])
+- Fix `Rails/HttpStatus` not working with custom HTTP status codes. ([@bquorning])
+- Fix `FactoryBot/StaticAttributeDefinedDynamically` to handle empty block. ([@abrom])
+- Fix false positive in `FactoryBot/DynamicAttributeDefinedStatically` when a before/after callback has a symbol proc argument. ([@abrom])
 
 ## 1.23.0 (2018-02-23)
 
-* Add `RSpec/Rails/HttpStatus` cop to enforce consistent usage of the status format (numeric or symbolic). ([@anthony-robin][], [@jojos003][])
-* Fix false negative in `RSpec/ReturnFromStub` when a constant is being returned by the stub. ([@Darhazer][])
-* Fix `FactoryBot/DynamicAttributeDefinedStatically` to handle dynamic attributes inside arrays/hashes. ([@abrom][])
-* Add `FactoryBot/StaticAttributeDefinedDynamically` (based on dynamic attribute cop). ([@abrom][])
+- Add `RSpec/Rails/HttpStatus` cop to enforce consistent usage of the status format (numeric or symbolic). ([@anthony-robin], [@jojos003])
+- Fix false negative in `RSpec/ReturnFromStub` when a constant is being returned by the stub. ([@Darhazer])
+- Fix `FactoryBot/DynamicAttributeDefinedStatically` to handle dynamic attributes inside arrays/hashes. ([@abrom])
+- Add `FactoryBot/StaticAttributeDefinedDynamically` (based on dynamic attribute cop). ([@abrom])
 
 ## 1.22.2 (2018-02-01)
 
-* Fix error in `RSpec/DescribedClass` when working on an empty `describe` block. ([@bquorning][])
+- Fix error in `RSpec/DescribedClass` when working on an empty `describe` block. ([@bquorning])
 
 ## 1.22.1 (2018-01-17)
 
-* Fix false positives in `RSpec/ReturnFromStub`. ([@Darhazer][])
+- Fix false positives in `RSpec/ReturnFromStub`. ([@Darhazer])
 
 ## 1.22.0 (2018-01-10)
 
-* Updates `describe_class` to account for RSpecs `:system` wrapper of rails system tests. ([@EliseFitz15][])
-* Add `RSpec/ExpectChange` cop to enforce consistent usage of the change matcher. ([@Darhazer][])
-* Add autocorrect support to `RSpec/LetBeforeExamples`. ([@Darhazer][])
-* Fix `RSpec/InstanceVariable` flagging instance variables inside dynamically defined class. ([@Darhazer][])
-* Add autocorrect support for `RSpec/ReturnFromStub` cop. ([@bquorning][])
-* Add `RSpec/ExampleWithoutDescription` cop. ([@Darhazer][])
+- Updates `describe_class` to account for RSpecs `:system` wrapper of rails system tests. ([@EliseFitz15])
+- Add `RSpec/ExpectChange` cop to enforce consistent usage of the change matcher. ([@Darhazer])
+- Add autocorrect support to `RSpec/LetBeforeExamples`. ([@Darhazer])
+- Fix `RSpec/InstanceVariable` flagging instance variables inside dynamically defined class. ([@Darhazer])
+- Add autocorrect support for `RSpec/ReturnFromStub` cop. ([@bquorning])
+- Add `RSpec/ExampleWithoutDescription` cop. ([@Darhazer])
 
 ## 1.21.0 (2017-12-13)
 
-* Compatibility with RuboCop v0.52.0. ([@bquorning][])
-* Improve performance when user does not override default RSpec Pattern config. ([@walf443][])
-* Add `AggregateFailuresByDefault` configuration for `RSpec/MultipleExpectations` cop. ([@onk][])
+- Compatibility with RuboCop v0.52.0. ([@bquorning])
+- Improve performance when user does not override default RSpec Pattern config. ([@walf443])
+- Add `AggregateFailuresByDefault` configuration for `RSpec/MultipleExpectations` cop. ([@onk])
 
 ## 1.20.1 (2017-11-15)
 
-* Add "without" to list of default allowed prefixes for `RSpec/ContextWording`. ([@bquorning][])
+- Add "without" to list of default allowed prefixes for `RSpec/ContextWording`. ([@bquorning])
 
 ## 1.20.0 (2017-11-09)
 
-* Rename namespace `FactoryGirl` to `FactoryBot` following original library update. ([@walf443][])
-* Fix exception in `RSpec/ReturnFromStub` on empty block. ([@yevhene][])
-* Add `RSpec/ContextWording` cop. ([@pirj][], [@telmofcosta][])
-* Fix `RSpec/SubjectStub` cop matches receive message inside all matcher. ([@walf443][])
+- Rename namespace `FactoryGirl` to `FactoryBot` following original library update. ([@walf443])
+- Fix exception in `RSpec/ReturnFromStub` on empty block. ([@yevhene])
+- Add `RSpec/ContextWording` cop. ([@pirj], [@telmofcosta])
+- Fix `RSpec/SubjectStub` cop matches receive message inside all matcher. ([@walf443])
 
 ## 1.19.0 (2017-10-18)
 
@@ -205,287 +716,366 @@ Compatibility release so users can upgrade RuboCop to 0.51.0. No new features.
 
 ## 1.18.0 (2017-09-29)
 
-* Fix false positive in `Capybara/FeatureMethods`. ([@Darhazer][])
-* Add `RSpec/Capybara/CurrentPathExpectation` cop for feature specs, disallowing setting expectations on `current_path`. ([@timrogers][])
-* Fix false positive in `RSpec/LetBeforeExamples` cop when example group contains single let. ([@Darhazer][])
+- Fix false positive in `Capybara/FeatureMethods`. ([@Darhazer])
+- Add `RSpec/Capybara/CurrentPathExpectation` cop for feature specs, disallowing setting expectations on `current_path`. ([@timrogers])
+- Fix false positive in `RSpec/LetBeforeExamples` cop when example group contains single let. ([@Darhazer])
 
 ## 1.17.1 (2017-09-20)
 
-* Improved `RSpec/ReturnFromStub` to handle string interpolation, hashes and do..end blocks. ([@Darhazer][])
-* Fixed compatibility with JRuby. ([@zverok][])
+- Improved `RSpec/ReturnFromStub` to handle string interpolation, hashes and do..end blocks. ([@Darhazer])
+- Fixed compatibility with JRuby. ([@zverok])
 
 ## 1.17.0 (2017-09-14)
 
-* Add `RSpec/Capybara` namespace including the first cop for feature specs: `Capybara/FeatureMethods`. ([@rspeicher][])
-* Update to RuboCop 0.50.0. ([@bquorning][])
+- Add `RSpec/Capybara` namespace including the first cop for feature specs: `Capybara/FeatureMethods`. ([@rspeicher])
+- Update to RuboCop 0.50.0. ([@bquorning])
 
 ## 1.16.0 (2017-09-06)
 
-* Add `RSpec/FactoryGirl` namespace including the first cop for factories: `FactoryGirl/DynamicAttributeDefinedStatically`. ([@jonatas][])
-* Add disabled by default `RSpec/AlignLeftLetBrace`. ([@backus][])
-* Add disabled by default `RSpec/AlignRightLetBrace`. ([@backus][])
-* Add `RSpec/LetBeforeExamples` cop. ([@Darhazer][])
-* Add `RSpec/MultipleSubjects` cop. ([@backus][])
-* Add `RSpec/ReturnFromStub` cop. ([@Darhazer][])
-* Add `RSpec/VoidExpect` cop. ([@pocke][])
-* Add `RSpec/InvalidPredicateMatcher` cop. ([@pocke][])
-* Change HookArgument cop to detect when hook has a receiver. ([@pocke][])
-* Add `RSpec/PredicateMatcher` cop. ([@pocke][])
-* Add `RSpec/ExpectInHook` cop. ([@pocke][])
-* `RSpec/MultipleExpectations` now detects usage of expect_any_instance_of. ([@Darhazer][])
-* `RSpec/MultipleExpectations` now detects usage of is_expected. ([@bmorrall][])
+- Add `RSpec/FactoryGirl` namespace including the first cop for factories: `FactoryGirl/DynamicAttributeDefinedStatically`. ([@jonatas])
+- Add disabled by default `RSpec/AlignLeftLetBrace`. ([@backus])
+- Add disabled by default `RSpec/AlignRightLetBrace`. ([@backus])
+- Add `RSpec/LetBeforeExamples` cop. ([@Darhazer])
+- Add `RSpec/MultipleSubjects` cop. ([@backus])
+- Add `RSpec/ReturnFromStub` cop. ([@Darhazer])
+- Add `RSpec/VoidExpect` cop. ([@pocke])
+- Add `RSpec/InvalidPredicateMatcher` cop. ([@pocke])
+- Change HookArgument cop to detect when hook has a receiver. ([@pocke])
+- Add `RSpec/PredicateMatcher` cop. ([@pocke])
+- Add `RSpec/ExpectInHook` cop. ([@pocke])
+- `RSpec/MultipleExpectations` now detects usage of expect_any_instance_of. ([@Darhazer])
+- `RSpec/MultipleExpectations` now detects usage of is_expected. ([@bmorrall])
 
 ## 1.15.1 (2017-04-30)
 
-* Fix the handling of various edge cases in the `RSpec/ExampleWording` cop, including one that would cause autocorrect to crash. ([@dgollahon][])
-* Fix `RSpec/IteratedExpectation` crashing when there is an assignment in the iteration. ([@Darhazer][])
-* Fix false positive in `RSpec/SingleArgumentMessageChain` cop when the single argument is a hash. ([@Darhazer][])
+- Fix the handling of various edge cases in the `RSpec/ExampleWording` cop, including one that would cause autocorrect to crash. ([@dgollahon])
+- Fix `RSpec/IteratedExpectation` crashing when there is an assignment in the iteration. ([@Darhazer])
+- Fix false positive in `RSpec/SingleArgumentMessageChain` cop when the single argument is a hash. ([@Darhazer])
 
 ## 1.15.0 (2017-03-24)
 
-* Add `RSpec/DescribeSymbol` cop. ([@rspeicher][])
-* Fix error when `RSpec/OverwritingSetup` and `RSpec/ScatteredLet` analyzed empty example groups. ([@backus][])
+- Add `RSpec/DescribeSymbol` cop. ([@rspeicher])
+- Fix error when `RSpec/OverwritingSetup` and `RSpec/ScatteredLet` analyzed empty example groups. ([@backus])
 
 ## 1.14.0 (2017-03-24)
 
-* Add `RSpec/OverwritingSetup` cop. ([@Darhazer][])
-* Add autocorrect support for `RSpec/LeadingSubject` cop. ([@Darhazer][])
-* Add `RSpec/ScatteredLet` cop. ([@Darhazer][])
-* Add `RSpec/IteratedExpectation` cop. ([@Darhazer][])
-* Add `RSpec/EmptyLineAfterSubject` cop. ([@Darhazer][])
-* Add `RSpec/EmptyLineAfterFinalLet` cop. ([@Darhazer][])
+- Add `RSpec/OverwritingSetup` cop. ([@Darhazer])
+- Add autocorrect support for `RSpec/LeadingSubject` cop. ([@Darhazer])
+- Add `RSpec/ScatteredLet` cop. ([@Darhazer])
+- Add `RSpec/IteratedExpectation` cop. ([@Darhazer])
+- Add `RSpec/EmptyLineAfterSubject` cop. ([@Darhazer])
+- Add `RSpec/EmptyLineAfterFinalLet` cop. ([@Darhazer])
 
 ## 1.13.0 (2017-03-07)
 
-* Add repeated 'it' detection to `RSpec/ExampleWording` cop. ([@dgollahon][])
-* Add [observed_nesting/max_nesting] info to `RSpec/NestedGroups` messages. ([@dgollahon][])
-* Add `RSpec/ItBehavesLike` cop. ([@dgollahon][])
-* Add `RSpec/SharedContext` cop. ([@Darhazer][])
-* `RSpec/MultipleExpectations`: Count aggregate_failures block as single expectation. ([@Darhazer][])
-* Fix `ExpectActual` cop flagging `rspec-rails` routing specs. ([@backus][])
-* Fix `FilePath` cop not registering offenses for files like `spec/blog/user.rb` when it should be `spec/blog/user_spec.rb`. ([@backus][])
+- Add repeated 'it' detection to `RSpec/ExampleWording` cop. ([@dgollahon])
+- Add [observed_nesting/max_nesting] info to `RSpec/NestedGroups` messages. ([@dgollahon])
+- Add `RSpec/ItBehavesLike` cop. ([@dgollahon])
+- Add `RSpec/SharedContext` cop. ([@Darhazer])
+- `RSpec/MultipleExpectations`: Count aggregate_failures block as single expectation. ([@Darhazer])
+- Fix `ExpectActual` cop flagging `rspec-rails` routing specs. ([@backus])
+- Fix `FilePath` cop not registering offenses for files like `spec/blog/user.rb` when it should be `spec/blog/user_spec.rb`. ([@backus])
 
 ## 1.12.0 (2017-02-21)
 
-* Add `RSpec/InstanceSpy` cop. ([@Darhazer][])
-* Add `RSpec/BeforeAfterAll` for avoiding leaky global test setup. ([@cfabianski][])
+- Add `RSpec/InstanceSpy` cop. ([@Darhazer])
+- Add `RSpec/BeforeAfterAll` for avoiding leaky global test setup. ([@cfabianski])
 
 ## 1.11.0 (2017-02-16)
 
-* Add `AroundBlock` cop. ([@Darhazer][])
-* Add `EnforcedStyle` configuration for `RSpec/DescribedClass` cop. ([@Darhazer][])
-* Fix false positive for `RSpec/RepeatedExample` cop. ([@redross][])
+- Add `AroundBlock` cop. ([@Darhazer])
+- Add `EnforcedStyle` configuration for `RSpec/DescribedClass` cop. ([@Darhazer])
+- Fix false positive for `RSpec/RepeatedExample` cop. ([@redross])
 
 ## 1.10.0 (2017-01-15)
 
-* Fix false negative for `RSpec/MessageSpies` cop. ([@onk][])
-* Fix internal dependencies on RuboCop to be compatible with 0.47 release. ([@backus][])
-* Add autocorrect support for `SingleArgumentMessageChain` cop. ([@bquorning][])
-* Rename `NestedGroups`' configuration key from `MaxNesting` to `Max` in order to be consistent with other cop configuration. ([@backus][])
-* Add `RepeatedExample` cop for detecting repeated examples within example groups. ([@backus][])
-* Add `ScatteredSetup` cop for enforcing that only one `before`, `around`, and `after` hook are used per example group scope. ([@backus][])
-* Add `ExpectOutput` cop for recommending `expect { ... }.to output(...).to_stdout`. ([@backus][])
+- Fix false negative for `RSpec/MessageSpies` cop. ([@onk])
+- Fix internal dependencies on RuboCop to be compatible with 0.47 release. ([@backus])
+- Add autocorrect support for `SingleArgumentMessageChain` cop. ([@bquorning])
+- Rename `NestedGroups`' configuration key from `MaxNesting` to `Max` in order to be consistent with other cop configuration. ([@backus])
+- Add `RepeatedExample` cop for detecting repeated examples within example groups. ([@backus])
+- Add `ScatteredSetup` cop for enforcing that only one `before`, `around`, and `after` hook are used per example group scope. ([@backus])
+- Add `ExpectOutput` cop for recommending `expect { ... }.to output(...).to_stdout`. ([@backus])
 
 ## 1.9.1 (2017-01-02)
 
-* Fix unintentional regression change in `NestedGroups` reported in #270. ([@backus][])
-* Change `MaxNesting` for `NestedGroups` from 2 to 3. ([@backus][])
+- Fix unintentional regression change in `NestedGroups` reported in #270. ([@backus])
+- Change `MaxNesting` for `NestedGroups` from 2 to 3. ([@backus])
 
 ## 1.9.0 (2016-12-29)
 
-* Add `MessageSpies` cop for enforcing consistent style of either `expect(...).to have_received` or `expect(...).to receive`, intended as a replacement for the `MessageExpectation` cop. ([@bquorning][])
-* Fix `DescribeClass` to not flag `describe` at the top of a block of shared examples. ([@clupprich][])
-* Add `SingleArgumentMessageChain` cop for recommending use of `receive` instead of `receive_message_chain` where possible. ([@bquorning][])
-* Add `RepeatedDescription` cop for detecting repeated example descriptions within example groups. ([@backus][])
+- Add `MessageSpies` cop for enforcing consistent style of either `expect(...).to have_received` or `expect(...).to receive`, intended as a replacement for the `MessageExpectation` cop. ([@bquorning])
+- Fix `DescribeClass` to not flag `describe` at the top of a block of shared examples. ([@clupprich])
+- Add `SingleArgumentMessageChain` cop for recommending use of `receive` instead of `receive_message_chain` where possible. ([@bquorning])
+- Add `RepeatedDescription` cop for detecting repeated example descriptions within example groups. ([@backus])
 
 ## 1.8.0 (2016-10-27)
 
-* Optionally ignore method names in the `describe` argument when running the `FilePath` cop. ([@bquorning][])
-* Fix regression in how `FilePath` converts alphanumeric class names into paths. ([@bquorning][])
-* Add `ImplicitExpect` cop for enforcing `should` vs. `is_expected.to`. ([@backus][])
-* Disable `MessageExpectation` cop in the default configuration. ([@bquorning][])
+- Optionally ignore method names in the `describe` argument when running the `FilePath` cop. ([@bquorning])
+- Fix regression in how `FilePath` converts alphanumeric class names into paths. ([@bquorning])
+- Add `ImplicitExpect` cop for enforcing `should` vs. `is_expected.to`. ([@backus])
+- Disable `MessageExpectation` cop in the default configuration. ([@bquorning])
 
 ## 1.7.0 (2016-08-24)
 
-* Add support for checking all example groups with `ExampleLength`. ([@backus][])
-* Add support for checking shared example groups for `DescribedClass`. ([@backus][])
-* Add support for checking `its` from [rspec-its](https://github.com/rspec/rspec-its). ([@backus][])
-* Add `EmptyExampleGroup` cop for detecting `describe`s and `context`s without any tests inside. ([@backus][])
-* Add `CustomIncludeMethods` configuration option for `EmptyExampleGroup`. ([@backus][])
-* Add `NestedGroups` cop for detecting excessive example group nesting. ([@backus][])
-* Add `MaxNesting` configuration option for `NestedGroups` cop. ([@backus][])
-* Add `ExpectActual` cop for detecting literal values within `expect(...)`. ([@backus][])
-* Add `MultipleExpectations` cop for detecting multiple `expect(...)` calls within one example. ([@backus][])
-* Add `Max` configuration option for `MultipleExpectations`. ([@backus][])
-* Add `SubjectStub` cop for testing stubbed test subjects. ([@backus][])
-* Add `LetSetup` cop for detecting cases where `let!` is used for test setup. ([@backus][])
-* Change all cops to only inspect files with names following rspec convention (`*/spec/*` and/or `_spec.rb`). ([@backus][])
-* Add `AllCops/RSpec` configuration option for specifying custom spec file patterns. ([@backus][])
-* Add `AssignmentOnly` configuration option for `RSpec/InstanceVariable` cop. ([@backus][])
-* Add `BeEql` cop which looks for expectations that can use `be(...)` instead of `eql(...)`. ([@backus][])
-* Add autocorrect support for `BeEql` cop. ([@backus][])
-* Add `MessageExpectation` cop for enforcing consistent style of either `expect(...).to receive` or `allow(...).to receive`. ([@backus][])
-* Add `MessageChain` cop. ([@bquorning][])
+- Add support for checking all example groups with `ExampleLength`. ([@backus])
+- Add support for checking shared example groups for `DescribedClass`. ([@backus])
+- Add support for checking `its` from [rspec-its](https://github.com/rspec/rspec-its). ([@backus])
+- Add `EmptyExampleGroup` cop for detecting `describe`s and `context`s without any tests inside. ([@backus])
+- Add `CustomIncludeMethods` configuration option for `EmptyExampleGroup`. ([@backus])
+- Add `NestedGroups` cop for detecting excessive example group nesting. ([@backus])
+- Add `MaxNesting` configuration option for `NestedGroups` cop. ([@backus])
+- Add `ExpectActual` cop for detecting literal values within `expect(...)`. ([@backus])
+- Add `MultipleExpectations` cop for detecting multiple `expect(...)` calls within one example. ([@backus])
+- Add `Max` configuration option for `MultipleExpectations`. ([@backus])
+- Add `SubjectStub` cop for testing stubbed test subjects. ([@backus])
+- Add `LetSetup` cop for detecting cases where `let!` is used for test setup. ([@backus])
+- Change all cops to only inspect files with names following rspec convention (`*/spec/*` and/or `_spec.rb`). ([@backus])
+- Add `AllCops/RSpec` configuration option for specifying custom spec file patterns. ([@backus])
+- Add `AssignmentOnly` configuration option for `RSpec/InstanceVariable` cop. ([@backus])
+- Add `BeEql` cop which looks for expectations that can use `be(...)` instead of `eql(...)`. ([@backus])
+- Add autocorrect support for `BeEql` cop. ([@backus])
+- Add `MessageExpectation` cop for enforcing consistent style of either `expect(...).to receive` or `allow(...).to receive`. ([@backus])
+- Add `MessageChain` cop. ([@bquorning])
 
 ## 1.6.0 (2016-08-03)
 
-* Add `SkipBlocks` option for `DescribedClass` cop. ([@backus][])
+- Add `SkipBlocks` option for `DescribedClass` cop. ([@backus])
 
 ## 1.5.3 (2016-08-02)
 
-* Add `RSpec/NamedSubject` cop. ([@backus][])
+- Add `RSpec/NamedSubject` cop. ([@backus])
 
 ## 1.5.2 (2016-08-01)
 
-* Drop support for ruby `2.0.0` and `2.1.0`. ([@backus][])
-* Internal refactorings and improved test coverage. ([@backus][])
+- Drop support for ruby `2.0.0` and `2.1.0`. ([@backus])
+- Internal refactorings and improved test coverage. ([@backus])
 
 ## 1.5.1 (2016-07-20)
 
-* Fix `unrecognized parameter RSpec/VerifiedDoubles:IgnoreSymbolicNames` warning. ([@jeffreyc][])
-* Update to rubocop 0.41.2. ([@backus][])
+- Fix `unrecognized parameter RSpec/VerifiedDoubles:IgnoreSymbolicNames` warning. ([@jeffreyc])
+- Update to rubocop 0.41.2. ([@backus])
 
 ## 1.5.0 (2016-05-17)
 
-* Expand `VerifiedDoubles` cop to check for `spy` as well as `double`. ([@andyw8][])
-* Enable `VerifiedDoubles` cop by default. ([@andyw8][])
-* Add `IgnoreSymbolicNames` option for `VerifiedDoubles` cop. ([@andyw8][])
-* Add `RSpec::ExampleLength` cop. ([@andyw8][])
-* Handle alphanumeric class names in `FilePath` cop. ([@andyw8][])
-* Skip `DescribeClass` cop for view specs. ([@andyw8][])
-* Skip `FilePath` cop for Rails routing specs. ([@andyw8][])
-* Add cop to check for focused specs. ([@renanborgescampos][], [@jaredmoody][])
-* Clean-up `RSpec::NotToNot` to use same configuration semantics as other Rubocop cops, add autocorrect support for `RSpec::NotToNot`. ([@baberthal][])
-* Update to rubocop 0.40.0. ([@nijikon][])
+- Expand `VerifiedDoubles` cop to check for `spy` as well as `double`. ([@andyw8])
+- Enable `VerifiedDoubles` cop by default. ([@andyw8])
+- Add `IgnoreSymbolicNames` option for `VerifiedDoubles` cop. ([@andyw8])
+- Add `RSpec::ExampleLength` cop. ([@andyw8])
+- Handle alphanumeric class names in `FilePath` cop. ([@andyw8])
+- Skip `DescribeClass` cop for view specs. ([@andyw8])
+- Skip `FilePath` cop for Rails routing specs. ([@andyw8])
+- Add cop to check for focused specs. ([@renanborgescampos], [@jaredmoody])
+- Clean-up `RSpec::NotToNot` to use same configuration semantics as other RuboCop cops, add autocorrect support for `RSpec::NotToNot`. ([@baberthal])
+- Update to rubocop 0.40.0. ([@nijikon])
 
 ## 1.4.1 (2016-04-03)
 
-* Ignore routing specs for DescribeClass cop. ([@nijikon][])
-* Move rubocop dependency to runtime. ([@nijikon][])
-* Update to rubocop 0.39.0. ([@nijikon][])
+- Ignore routing specs for DescribeClass cop. ([@nijikon])
+- Move rubocop dependency to runtime. ([@nijikon])
+- Update to rubocop 0.39.0. ([@nijikon])
 
 ## 1.4.0 (2016-02-15)
 
-* Update to rubocop 0.37.2. ([@nijikon][])
-* Update ruby versions we test against. ([@nijikon][])
-* Add `RSpec::NotToNot` cop. ([@miguelfteixeira][])
-* Add `RSpec/AnyInstance` cop. ([@mlarraz][])
+- Update to rubocop 0.37.2. ([@nijikon])
+- Update ruby versions we test against. ([@nijikon])
+- Add `RSpec::NotToNot` cop. ([@miguelfteixeira])
+- Add `RSpec/AnyInstance` cop. ([@mlarraz])
 
 ## 1.3.1
 
-* Fix auto correction issue - syntax had changed in RuboCop v0.31. ([@bquorning][])
-* Add RuboCop clone to vendor folder - see #39 for details. ([@bquorning][])
+- Fix auto correction issue - syntax had changed in RuboCop v0.31. ([@bquorning])
+- Add RuboCop clone to vendor folder - see #39 for details. ([@bquorning])
 
 ## 1.3.0
 
-* Ignore non string arguments for FilePathCop - thanks to @deivid-rodriguez. ([@geniou][])
-* Skip DescribeMethod cop for tagged specs. ([@deivid-rodriguez][])
-* Skip DescribeClass cop for feature/request specs. ([@deivid-rodriguez][])
+- Ignore non string arguments for FilePathCop - thanks to @deivid-rodriguez. ([@geniou])
+- Skip DescribeMethod cop for tagged specs. ([@deivid-rodriguez])
+- Skip DescribeClass cop for feature/request specs. ([@deivid-rodriguez])
 
 ## 1.2.2
 
-* Make `RSpec::ExampleWording` case insensitive. ([@geniou][])
+- Make `RSpec::ExampleWording` case insensitive. ([@geniou])
 
 ## 1.2.1
 
-* Add `RSpec::VerifiedDoubles` cop. ([@andyw8][])
+- Add `RSpec::VerifiedDoubles` cop. ([@andyw8])
 
 ## 1.2.0
 
-* Drop support of ruby `1.9.2`. ([@geniou][])
-* Update to RuboCop `~> 0.24`. ([@geniou][])
-* Add `autocorrect` to `RSpec::ExampleWording`. This experimental - use with care and check the changes. ([@geniou][])
-* Fix config loader debug output. ([@geniou][])
-* Rename `FileName` cop to `FilePath` as a workaround - see [#19](https://github.com/nevir/rubocop-rspec/issues/19). ([@geniou][])
+- Drop support of ruby `1.9.2`. ([@geniou])
+- Update to RuboCop `~> 0.24`. ([@geniou])
+- Add `autocorrect` to `RSpec::ExampleWording`. This experimental - use with care and check the changes. ([@geniou])
+- Fix config loader debug output. ([@geniou])
+- Rename `FileName` cop to `FilePath` as a workaround - see [#19](https://github.com/nevir/rubocop-rspec/issues/19). ([@geniou])
 
 ## 1.1.0
 
-* Add `autocorrect` to `RSpec::DescribedClass` cop. ([@geniou][])
+- Add `autocorrect` to `RSpec::DescribedClass` cop. ([@geniou])
 
 ## 1.0.1
 
-* Add `config` folder to gemspec. ([@pstengel][])
+- Add `config` folder to gemspec. ([@pstengel])
 
 ## 1.0.rc3
 
-* Update to RuboCop `>= 0.23`. ([@geniou][])
-* Add configuration option for `CustomTransformation` to `FileName` cop. ([@geniou][])
+- Update to RuboCop `>= 0.23`. ([@geniou])
+- Add configuration option for `CustomTransformation` to `FileName` cop. ([@geniou])
 
 ## 1.0.rc2
 
-* Gem is no longer 20MB (sorry!). ([@nevir][])
-* `RspecFileName` cop allows for method specs to organized into directories by class and type. ([@nevir][])
+- Gem is no longer 20MB (sorry!). ([@nevir])
+- `RspecFileName` cop allows for method specs to organized into directories by class and type. ([@nevir])
 
 ## 1.0.rc1
 
-* Update code to work with rubocop `>= 0.19`. ([@geniou][])
-* Split `UnitSpecNaming` cop into `RSpecDescribeClass`, `RSpecDescribeMethod` and `RSpecFileName` and enabled them all by default. ([@geniou][])
-* Add `RSpecExampleWording` cop to prevent to use of should at the beginning of the spec description. ([@geniou][])
-* Fix `RSpecFileName` cop for non-class specs. ([@geniou][])
-* Adapt `RSpecFileName` cop to commen naming convention and skip spec with multiple top level describes. ([@geniou][])
-* Add `RSpecMultipleDescribes` cop to check for multiple top level describes. ([@geniou][])
-* Add `RSpecDescribedClass` to promote the use of `described_class`. ([@geniou][])
-* Add `RSpecInstanceVariable` cop to check for the usage of instance variables. ([@geniou][])
+- Update code to work with rubocop `>= 0.19`. ([@geniou])
+- Split `UnitSpecNaming` cop into `RSpecDescribeClass`, `RSpecDescribeMethod` and `RSpecFileName` and enabled them all by default. ([@geniou])
+- Add `RSpecExampleWording` cop to prevent to use of should at the beginning of the spec description. ([@geniou])
+- Fix `RSpecFileName` cop for non-class specs. ([@geniou])
+- Adapt `RSpecFileName` cop to common naming convention and skip spec with multiple top level describes. ([@geniou])
+- Add `RSpecMultipleDescribes` cop to check for multiple top level describes. ([@geniou])
+- Add `RSpecDescribedClass` to promote the use of `described_class`. ([@geniou])
+- Add `RSpecInstanceVariable` cop to check for the usage of instance variables. ([@geniou])
 
-<!-- Contributors -->
+<!-- Contributors (alphabetically) -->
 
+[@aarestad]: https://github.com/aarestad
+[@abrom]: https://github.com/abrom
+[@ahukkanen]: https://github.com/ahukkanen
+[@akiomik]: https://github.com/akiomik
+[@akrox58]: https://github.com/akrox58
+[@alexwayfer]: https://github.com/AlexWayfer
+[@andrykonchin]: https://github.com/andrykonchin
 [@andyw8]: https://github.com/andyw8
+[@anthony-robin]: https://github.com/anthony-robin
+[@aried3r]: https://github.com/aried3r
+[@baberthal]: https://github.com/baberthal
 [@backus]: https://github.com/backus
+[@bcgraham]: https://github.com/bcgraham
+[@biinari]: https://github.com/biinari
+[@bmorrall]: https://github.com/bmorrall
 [@bquorning]: https://github.com/bquorning
+[@brentwheeldon]: https://github.com/BrentWheeldon
+[@brianhawley]: https://github.com/BrianHawley
+[@cbliard]: https://github.com/cbliard
+[@cfabianski]: https://github.com/cfabianski
+[@clupprich]: https://github.com/clupprich
+[@composerinteralia]: https://github.com/composerinteralia
+[@corsonknowles]: https://github.com/corsonknowles
+[@corydiamand]: https://github.com/corydiamand
+[@darhazer]: https://github.com/Darhazer
+[@daveworth]: https://github.com/daveworth
+[@dduugg]: https://github.com/dduugg
 [@deivid-rodriguez]: https://github.com/deivid-rodriguez
+[@dgollahon]: https://github.com/dgollahon
+[@dmitrytsepelev]: https://github.com/dmitrytsepelev
+[@drcapulet]: https://github.com/drcapulet
+[@drowze]: https://github.com/Drowze
+[@dswij]: https://github.com/dswij
+[@dvandersluis]: https://github.com/dvandersluis
+[@earlopain]: https://github.com/earlopain
+[@edgibbs]: https://github.com/edgibbs
+[@eikes]: https://github.com/eikes
+[@eitoball]: https://github.com/eitoball
+[@elebow]: https://github.com/elebow
+[@elisefitz15]: https://github.com/EliseFitz15
+[@elliterate]: https://github.com/elliterate
+[@faucct]: https://github.com/faucct
+[@foton]: https://github.com/foton
+[@francois-ferrandis]: https://github.com/francois-ferrandis
+[@franzliedke]: https://github.com/franzliedke
+[@g-rath]: https://github.com/G-Rath
 [@geniou]: https://github.com/geniou
+[@gsamokovarov]: https://github.com/gsamokovarov
+[@harry-graham]: https://github.com/harry-graham
+[@harrylewis]: https://github.com/harrylewis
+[@hasghari]: https://github.com/hasghari
+[@hosamaly]: https://github.com/hosamaly
+[@ignaciovillaverde]: https://github.com/ignaciovillaverde
 [@jaredbeck]: https://github.com/jaredbeck
-[@jawshooah]: https://github.com/jawshooah
-[@nevir]: https://github.com/nevir
-[@nijikon]: https://github.com/nijikon
-[@pstengel]: https://github.com/pstengel
-[@miguelfteixeira]: https://github.com/miguelfteixeira
-[@mlarraz]: https://github.com/mlarraz
-[@renanborgescampos]: https://github.com/renanborgescampos
 [@jaredmoody]: https://github.com/jaredmoody
-[@baberthal]: https://github.com/baberthal
+[@jdufresne]: https://github.com/jdufresne
 [@jeffreyc]: https://github.com/jeffreyc
-[@clupprich]: https://github.com/clupprich
+[@jeppester]: https://github.com/jeppester
+[@jessieay]: https://github.com/jessieay
+[@jfragoulis]: https://github.com/jfragoulis
+[@johnny-miyake]: https://github.com/johnny-miyake
+[@jojos003]: https://github.com/jojos003
+[@jonatas]: https://github.com/jonatas
+[@jtannas]: https://github.com/jtannas
+[@k-s-a]: https://github.com/K-S-A
+[@kellysutton]: https://github.com/kellysutton
+[@koic]: https://github.com/koic
+[@krororo]: https://github.com/krororo
+[@kuahyeow]: https://github.com/kuahyeow
+[@lazycoder9]: https://github.com/lazycoder9
+[@lee266]: https://github.com/lee266
+[@leoarnold]: https://github.com/leoarnold
+[@liberatys]: https://github.com/Liberatys
+[@lokhi]: https://github.com/lokhi
+[@lovro-bikic]: https://github.com/lovro-bikic
+[@luke-hill]: https://github.com/luke-hill
+[@m-yamashita01]: https://github.com/M-Yamashita01
+[@marocchino]: https://github.com/marocchino
+[@miguelfteixeira]: https://github.com/miguelfteixeira
+[@mkenyon]: https://github.com/mkenyon
+[@mkrawc]: https://github.com/mkrawc
+[@mlarraz]: https://github.com/mlarraz
+[@mockdeep]: https://github.com/mockdeep
+[@mothonmars]: https://github.com/MothOnMars
+[@mvz]: https://github.com/mvz
+[@naveg]: https://github.com/naveg
+[@nc-holodakg]: https://github.com/nc-holodakg
+[@nevir]: https://github.com/nevir
+[@ngouy]: https://github.com/ngouy
+[@nickcampbell18]: https://github.com/nickcampbell18
+[@nijikon]: https://github.com/nijikon
 [@onk]: https://github.com/onk
-[@Darhazer]: https://github.com/Darhazer
+[@onumis]: https://github.com/onumis
+[@oshiro3]: https://github.com/oshiro3
+[@patrickomatic]: https://github.com/patrickomatic
+[@paydaylight]: https://github.com/paydaylight
+[@philcoggins]: https://github.com/PhilCoggins
+[@pirj]: https://github.com/pirj
+[@pocke]: https://github.com/pocke
+[@pstengel]: https://github.com/pstengel
+[@qqism]: https://github.com/QQism
+[@r7kamura]: https://github.com/r7kamura
+[@rafix02]: https://github.com/Rafix02
 [@redross]: https://github.com/redross
-[@cfabianski]: https://github.com/cfabianski
-[@dgollahon]: https://github.com/dgollahon
+[@renanborgescampos]: https://github.com/renanborgescampos
+[@robinaugh]: https://github.com/robinaugh
+[@robotdana]: https://github.com/robotdana
+[@rolfschmidt]: https://github.com/rolfschmidt
+[@rrosenblum]: https://github.com/rrosenblum
 [@rspeicher]: https://github.com/rspeicher
-[@jonatas]: https://github.com/jonatas
-[@pocke]: https://github.com/pocke
-[@bmorrall]: https:/github.com/bmorrall
-[@zverok]: https:/github.com/zverok
-[@timrogers]: https://github.com/timrogers
-[@yevhene]: https://github.com/yevhene
-[@walf443]: https://github.com/walf443
-[@pirj]: https://github.com/pirj
-[@telmofcosta]: https://github.com/telmofcosta
-[@EliseFitz15]: https://github.com/EliseFitz15
-[@anthony-robin]: https://github.com/anthony-robin
-[@jojos003]: https://github.com/jojos003
-[@abrom]: https://github.com/abrom
-[@patrickomatic]: https://github.com/patrickomatic
-[@tdeo]: https://github.com/tdeo
-[@composerinteralia]: https://github.com/composerinteralia
+[@rst-j]: https://github.com/RST-J
+[@sakuro]: https://github.com/sakuro
+[@samrjenkins]: https://github.com/samrjenkins
+[@schmijos]: https://github.com/schmijos
 [@seanpdoyle]: https://github.com/seanpdoyle
+[@sl4vr]: https://github.com/sl4vr
+[@smcgivern]: https://github.com/smcgivern
+[@splattael]: https://github.com/splattael
+[@stephannv]: https://github.com/stephannv
+[@swelther]: https://github.com/swelther
+[@t3h2mas]: https://github.com/t3h2mas
+[@tdeo]: https://github.com/tdeo
+[@tejasbubane]: https://github.com/tejasbubane
+[@telmofcosta]: https://github.com/telmofcosta
+[@tietew]: https://github.com/Tietew
+[@timrogers]: https://github.com/timrogers
+[@tmaier]: https://github.com/tmaier
+[@topalovic]: https://github.com/topalovic
+[@twalpole]: https://github.com/twalpole
 [@vzvu3k6k]: https://github.com/vzvu3k6k
-[@BrentWheeldon]: https://github.com/BrentWheeldon
-[@daveworth]: https://github.com/daveworth
-[@RST-J]: https://github.com/RST-J
-[@ypresto]: https://github.com/ypresto
-[@mkenyon]: https://github.com/mkenyon
-[@gsamokovarov]: https://github.com/gsamokovarov
-[@schmijos]: https://github.com/schmijos
-[@foton]: https://github.com/foton
-[@nc-holodakg]: https://github.com/nc-holodakg
-[@onumis]: https://github.com/onumis
-[@nickcampbell18]: https://github.com/nickcampbell18
-[@QQism]: https://github.com/QQism
-[@kellysutton]: https://github.com/kellysutton
-[@mkrawc]: https://github.com/mkrawc
-[@jfragoulis]: https://github.com/jfragoulis
+[@walf443]: https://github.com/walf443
+[@yasu551]: https://github.com/yasu551
 [@ybiquitous]: https://github.com/ybiquitous
-[@dduugg]: https://github.com/dduugg
-[@lazycoder9]: https://github.com/lazycoder9
-[@elebow]: https://github.com/elebow
+[@ydah]: https://github.com/ydah
+[@yevhene]: https://github.com/yevhene
+[@ypresto]: https://github.com/ypresto
+[@yujideveloper]: https://github.com/yujideveloper
+[@zdennis]: https://github.com/zdennis
+[@zverok]: https://github.com/zverok
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..6e5a0ce2b
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,17 @@
+# The RuboCop Community Code of Conduct
+
+**Note:** We have picked the following code of conduct based on [Ruby's own
+code of conduct](https://www.ruby-lang.org/en/conduct/).
+
+This document provides a few simple community guidelines for a safe, respectful,
+productive, and collaborative place for any person who is willing to contribute
+to the RuboCop community. It applies to all "collaborative spaces", which are
+defined as community communications channels (such as mailing lists, submitted
+patches, commit comments, etc.).
+
+- Participants will be tolerant of opposing views.
+- Participants must ensure that their language and actions are free of personal
+  attacks and disparaging personal remarks.
+- When interpreting the words and actions of others, participants should always
+  assume good intentions.
+- Behaviour which can be reasonably considered harassment will not be tolerated.
diff --git a/Gemfile b/Gemfile
index 515dec7c8..089cdf4e6 100644
--- a/Gemfile
+++ b/Gemfile
@@ -4,8 +4,14 @@ source 'https://rubygems.org'
 
 gemspec
 
-local_gemfile = 'Gemfile.local'
+gem 'bump'
+gem 'rack'
+gem 'rake'
+gem 'rspec', '~> 3.11'
+gem 'rubocop-performance', '~> 1.24'
+gem 'rubocop-rake', '~> 0.7'
+gem 'simplecov', '>= 0.19'
+gem 'yard'
 
-if File.exist?(local_gemfile)
-  eval(File.read(local_gemfile)) # rubocop:disable Security/Eval
-end
+local_gemfile = 'Gemfile.local'
+eval_gemfile(local_gemfile) if File.exist?(local_gemfile)
diff --git a/MIT-LICENSE.md b/MIT-LICENSE.md
index c628b7a91..e32542a9c 100644
--- a/MIT-LICENSE.md
+++ b/MIT-LICENSE.md
@@ -1,5 +1,4 @@
-The MIT License (MIT)
-=====================
+# The MIT License (MIT)
 
 Copyright (c) 2014 Ian MacLeod <ian@nevir.net>
 
diff --git a/README.md b/README.md
index 50c2162f5..938a8f0d7 100644
--- a/README.md
+++ b/README.md
@@ -2,12 +2,19 @@
 
 [![Join the chat at https://gitter.im/rubocop-rspec/Lobby](https://badges.gitter.im/rubocop-rspec/Lobby.svg)](https://gitter.im/rubocop-rspec/Lobby)
 [![Gem Version](https://badge.fury.io/rb/rubocop-rspec.svg)](https://rubygems.org/gems/rubocop-rspec)
-[![CircleCI](https://circleci.com/gh/rubocop-hq/rubocop-rspec.svg?style=svg)](https://circleci.com/gh/rubocop-hq/rubocop-rspec)
-[![Test Coverage](https://api.codeclimate.com/v1/badges/8ffaabf633c968c22bdd/test_coverage)](https://codeclimate.com/github/rubocop-hq/rubocop-rspec/test_coverage)
-[![Maintainability](https://api.codeclimate.com/v1/badges/8ffaabf633c968c22bdd/maintainability)](https://codeclimate.com/github/rubocop-hq/rubocop-rspec/maintainability)
+![CI](https://github.com/rubocop/rubocop-rspec/workflows/CI/badge.svg)
 
-RSpec-specific analysis for your projects, as an extension to
-[RuboCop](https://github.com/rubocop-hq/rubocop).
+[RSpec](https://rspec.info/)-specific analysis for your projects, as an extension to
+[RuboCop](https://github.com/rubocop/rubocop).
+
+- [Installation](#installation)
+  - [Upgrading to RuboCop RSpec v3.x](#upgrading-to-rubocop-rspec-v3x)
+  - [Upgrading to RuboCop RSpec v2.x](#upgrading-to-rubocop-rspec-v2x)
+- [Usage](#usage)
+- [Documentation](#documentation)
+- [The Cops](#the-cops)
+- [Contributing](#contributing)
+- [License](#license)
 
 ## Installation
 
@@ -19,10 +26,18 @@ gem install rubocop-rspec
 
 or if you use bundler put this in your `Gemfile`
 
-```
+```ruby
 gem 'rubocop-rspec', require: false
 ```
 
+### Upgrading to RuboCop RSpec v3.x
+
+Read all the details in our [Upgrade to Version 3.x](https://docs.rubocop.org/rubocop-rspec/3.0/upgrade_to_version_3.html) document.
+
+### Upgrading to RuboCop RSpec v2.x
+
+Read all the details in our [Upgrade to Version 2.x](https://docs.rubocop.org/rubocop-rspec/2.0/upgrade_to_version_2.html) document.
+
 ## Usage
 
 You need to tell RuboCop to load the RSpec extension. There are three
@@ -33,13 +48,13 @@ ways to do this:
 Put this into your `.rubocop.yml`.
 
 ```yaml
-require: rubocop-rspec
+plugins: rubocop-rspec
 ```
 
 Alternatively, use the following array notation when specifying multiple extensions.
 
 ```yaml
-require:
+plugins:
   - rubocop-other-extension
   - rubocop-rspec
 ```
@@ -47,47 +62,30 @@ require:
 Now you can run `rubocop` and it will automatically load the RuboCop RSpec
 cops together with the standard cops.
 
+> [!NOTE]
+> The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
 ### Command line
 
 ```bash
-rubocop --require rubocop-rspec
+rubocop --plugin rubocop-rspec
 ```
 
 ### Rake task
 
 ```ruby
 RuboCop::RakeTask.new do |task|
-  task.requires << 'rubocop-rspec'
+  task.plugins << 'rubocop-rspec'
 end
 ```
 
 ### Code Climate
 
-rubocop-rspec is available on Code Climate as part of the rubocop engine. [Learn More](https://codeclimate.com/changelog/55a433bbe30ba00852000fac).
+rubocop-rspec is available on Code Climate as part of the rubocop engine. [Learn More](https://marketing.codeclimate.com/changelog/55a433bbe30ba00852000fac/).
 
 ## Documentation
 
-You can read more about RuboCop-RSpec in its [official manual](http://rubocop-rspec.readthedocs.io).
-
-## Inspecting files that don't end with `_spec.rb`
-
-By default, `rubocop-rspec` only inspects code within paths ending in `_spec.rb` or including `spec/`. You can override this setting in your config file by specifying one or more patterns:
-
-```yaml
-# Inspect all files
-AllCops:
-  RSpec:
-    Patterns:
-    - '.+'
-```
-
-```yaml
-# Inspect only files ending with `_test.rb`
-AllCops:
-  RSpec:
-    Patterns:
-    - '_test.rb$'
-```
+You can read more about RuboCop RSpec in its [official manual](https://docs.rubocop.org/rubocop-rspec).
 
 ## The Cops
 
@@ -99,51 +97,11 @@ In your `.rubocop.yml`, you may treat the RSpec cops just like any other
 cop. For example:
 
 ```yaml
-RSpec/FilePath:
+RSpec/SpecFilePathFormat:
   Exclude:
     - spec/my_poorly_named_spec_file.rb
 ```
 
-## Non-goals of RuboCop RSpec
-
-### Enforcing `should` vs. `expect` syntax
-
-Enforcing
-
-```ruby
-expect(calculator.compute(line_item)).to eq(5)
-```
-
-over
-
-```ruby
-calculator.compute(line_item).should == 5
-```
-
-is a feature of RSpec itself – you can read about it in the [RSpec Documentation](https://relishapp.com/rspec/rspec-expectations/docs/syntax-configuration#disable-should-syntax)
-
-### Enforcing an explicit RSpec receiver for top-level methods (disabling monkey patching)
-
-Enforcing
-
-```ruby
-RSpec.describe MyClass do
-  ...
-end
-```
-
-over
-
-```ruby
-describe MyClass do
-  ...
-end
-```
-
-can be achieved using RSpec's `disable_monkey_patching!` method, which you can read more about in the [RSpec Documentation](https://relishapp.com/rspec/rspec-core/v/3-7/docs/configuration/zero-monkey-patching-mode#monkey-patched-methods-are-undefined-with-%60disable-monkey-patching!%60). This will also prevent `should` from being defined on every object in your system.
-
-Before disabling `should` you will need all your specs to use the `expect` syntax. You can use [Transpec](http://yujinakayama.me/transpec/), which will do the conversion for you.
-
 ## Contributing
 
 Checkout the [contribution guidelines](.github/CONTRIBUTING.md).
diff --git a/Rakefile b/Rakefile
index 4bea106c9..23d584ed0 100644
--- a/Rakefile
+++ b/Rakefile
@@ -14,6 +14,7 @@ rescue Bundler::BundlerError => e
 end
 
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
 Dir['tasks/**/*.rake'].each { |t| load t }
 
@@ -21,20 +22,39 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-desc 'Run RSpec with code coverage'
-task :coverage do
-  ENV['COVERAGE'] = 'true'
-  Rake::Task['spec'].execute
-end
-
 desc 'Run RuboCop over this gem'
-task :internal_investigation do
-  sh('bundle exec rubocop --require rubocop-rspec')
-end
+RuboCop::RakeTask.new(:internal_investigation)
 
 desc 'Build config/default.yml'
 task :build_config do
-  sh('bin/build_config')
+  require 'yard'
+
+  require 'rubocop-rspec'
+  require 'rubocop/rspec/config_formatter'
+  require 'rubocop/rspec/description_extractor'
+
+  glob = File.join('lib', 'rubocop', 'cop', 'rspec', '*.rb')
+  # Due to YARD's sensitivity to file require order (as of 0.9.25),
+  # we have to prepend the list with our base cop, RuboCop::Cop::RSpec::Base.
+  # Otherwise, cop's parent class for cops loaded before our base cop class
+  # are detected as RuboCop::Cop::Base, and that complicates the detection
+  # of their relation with RuboCop RSpec.
+  rspec_cop_path = File.join('lib', 'rubocop', 'cop', 'rspec', 'base.rb')
+  YARD::Tags::Library.define_tag('Cop Safety Information', :safety)
+  YARD.parse(Dir[glob].prepend(rspec_cop_path), [])
+
+  descriptions =
+    RuboCop::RSpec::DescriptionExtractor.new(YARD::Registry.all(:class)).to_h
+  current_config = if Psych::VERSION >= '4.0.0' # RUBY_VERSION >= '3.1.0'
+                     YAML.unsafe_load_file('config/default.yml')
+                   else
+                     YAML.load_file('config/default.yml')
+                   end
+
+  File.write(
+    'config/default.yml',
+    RuboCop::RSpec::ConfigFormatter.new(current_config, descriptions).dump
+  )
 end
 
 desc 'Confirm config/default.yml is up to date'
@@ -42,23 +62,29 @@ task confirm_config: :build_config do
   _, stdout, _, process =
     Open3.popen3('git diff --exit-code config/default.yml')
 
-  unless process.value.success?
-    raise "default.yml is out of sync:\n\n#{stdout.read}\nRun bin/build_config"
-  end
+  raise <<~ERROR unless process.value.success?
+    default.yml is out of sync:
+
+    #{stdout.read}
+    Please run `rake build_config`
+  ERROR
 end
 
 desc 'Confirm documentation is up to date'
 task confirm_documentation: :generate_cops_documentation do
-  _, _, _, process =
-    Open3.popen3('git diff --exit-code manual/')
-
-  unless process.value.success?
-    raise 'Please run `rake generate_cops_documentation` ' \
-          'and add manual/ to the commit.'
+  stdout, _stderr, status =
+    Open3.capture3('git diff --exit-code docs/')
+
+  unless status.success?
+    warn 'Documentation is out of sync:'
+    warn stdout
+    warn 'Please run `rake generate_cops_documentation` ' \
+         'and add docs/ to the commit.'
+    exit 1
   end
 end
 
-task default: %i[build_config coverage
+task default: %i[build_config spec
                  internal_investigation
                  confirm_config
                  documentation_syntax_check
@@ -67,21 +93,18 @@ task default: %i[build_config coverage
 desc 'Generate a new cop template'
 task :new_cop, [:cop] do |_task, args|
   require 'rubocop'
+  require_relative 'lib/rubocop/rspec/cop/generator'
 
   cop_name = args.fetch(:cop) do
-    warn 'usage: bundle exec rake new_cop[Department/Name]'
+    warn "usage: bundle exec rake 'new_cop[Department/Name]'"
     exit!
   end
 
-  github_user = `git config github.user`.chop
-  github_user = 'your_id' if github_user.empty?
-
-  generator = RuboCop::Cop::Generator.new(cop_name, github_user)
-
+  generator = RuboCop::RSpec::Cop::Generator.new(cop_name)
   generator.write_source
   generator.write_spec
   generator.inject_require(root_file_path: 'lib/rubocop/cop/rspec_cops.rb')
-  generator.inject_config(config_file_path: 'config/default.yml')
+  generator.inject_config
 
   puts generator.todo
 end
diff --git a/bin/build_config b/bin/build_config
deleted file mode 100755
index 35ec1641f..000000000
--- a/bin/build_config
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
-
-require 'yard'
-
-require 'rubocop-rspec'
-require 'rubocop/rspec/description_extractor'
-require 'rubocop/rspec/config_formatter'
-
-glob = File.join(__dir__, '..', 'lib', 'rubocop', 'cop', 'rspec',
-                 '{,capybara,factory_bot,rails}', '*.rb')
-YARD.parse(Dir[glob], [])
-
-descriptions = RuboCop::RSpec::DescriptionExtractor.new(YARD::Registry.all).to_h
-current_config = YAML.load_file('config/default.yml')
-
-File.write(
-  'config/default.yml',
-  RuboCop::RSpec::ConfigFormatter.new(current_config, descriptions).dump
-)
diff --git a/config/default.yml b/config/default.yml
index 739e3afd4..ca2f05531 100644
--- a/config/default.yml
+++ b/config/default.yml
@@ -1,151 +1,410 @@
 ---
-AllCops:
-  RSpec:
-    Patterns:
-    - _spec.rb
-    - "(?:^|/)spec/"
-  RSpec/FactoryBot:
-    Patterns:
-    - spec/factories.rb
-    - spec/factories/**/*.rb
-    - features/support/factories/**/*.rb
+RSpec:
+  Enabled: true
+  StyleGuideBaseURL: https://rspec.rubystyle.guide
+  DocumentationBaseURL: https://docs.rubocop.org/rubocop-rspec
+  Include:
+    - "**/*_spec.rb"
+    - "**/spec/**/*"
+  Language:
+    inherit_mode:
+      merge:
+        - Expectations
+        - Helpers
+        - Hooks
+        - Subjects
+    ExampleGroups:
+      inherit_mode:
+        merge:
+          - Regular
+          - Skipped
+          - Focused
+      Regular:
+        - describe
+        - context
+        - feature
+        - example_group
+      Skipped:
+        - xdescribe
+        - xcontext
+        - xfeature
+      Focused:
+        - fdescribe
+        - fcontext
+        - ffeature
+    Examples:
+      inherit_mode:
+        merge:
+          - Regular
+          - Skipped
+          - Focused
+          - Pending
+      Regular:
+        - it
+        - specify
+        - example
+        - scenario
+        - its
+      Focused:
+        - fit
+        - fspecify
+        - fexample
+        - fscenario
+        - focus
+      Skipped:
+        - xit
+        - xspecify
+        - xexample
+        - xscenario
+        - skip
+      Pending:
+        - pending
+    Expectations:
+      - are_expected
+      - expect
+      - expect_any_instance_of
+      - is_expected
+      - should
+      - should_not
+      - should_not_receive
+      - should_receive
+    Helpers:
+      - let
+      - let!
+    Hooks:
+      - prepend_before
+      - before
+      - append_before
+      - around
+      - prepend_after
+      - after
+      - append_after
+    Includes:
+      inherit_mode:
+        merge:
+          - Examples
+          - Context
+      Examples:
+        - it_behaves_like
+        - it_should_behave_like
+        - include_examples
+      Context:
+        - include_context
+    SharedGroups:
+      inherit_mode:
+        merge:
+          - Examples
+          - Context
+      Examples:
+        - shared_examples
+        - shared_examples_for
+      Context:
+        - shared_context
+    Subjects:
+      - subject
+      - subject!
+
+Metrics/BlockLength:
+  inherit_mode:
+    merge:
+      - Exclude
+  Exclude:
+    - "**/*_spec.rb"
+    - "**/spec/**/*"
 
 RSpec/AlignLeftLetBrace:
   Description: Checks that left braces for adjacent single line lets are aligned.
   Enabled: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace
+  VersionAdded: '1.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace
 
 RSpec/AlignRightLetBrace:
   Description: Checks that right braces for adjacent single line lets are aligned.
   Enabled: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace
+  VersionAdded: '1.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace
 
 RSpec/AnyInstance:
   Description: Check that instances are not being stubbed globally.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance
+  VersionAdded: '1.4'
+  StyleGuide: https://rspec.rubystyle.guide/#any_instance_of
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance
 
 RSpec/AroundBlock:
   Description: Checks that around blocks actually run the test.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock
+  VersionAdded: '1.11'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock
 
 RSpec/Be:
   Description: Check for expectations where `be` is used without argument.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be
+  VersionAdded: '1.25'
+  StyleGuide: https://rspec.rubystyle.guide/#be-matcher
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be
+
+RSpec/BeEmpty:
+  Description: Prefer using `be_empty` when checking for an empty array.
+  Enabled: true
+  AutoCorrect: contextual
+  VersionAdded: '2.20'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEmpty
+
+RSpec/BeEq:
+  Description: Check for expectations where `be(...)` can replace `eq(...)`.
+  Enabled: true
+  Safe: false
+  VersionAdded: 2.9.0
+  VersionChanged: '2.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEq
 
 RSpec/BeEql:
   Description: Check for expectations where `be(...)` can replace `eql(...)`.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql
+  Safe: false
+  VersionAdded: '1.7'
+  VersionChanged: '2.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql
+
+RSpec/BeNil:
+  Description: Ensures a consistent style is used when matching `nil`.
+  Enabled: true
+  EnforcedStyle: be_nil
+  SupportedStyles:
+    - be
+    - be_nil
+  VersionAdded: 2.9.0
+  VersionChanged: 2.10.0
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeNil
 
 RSpec/BeforeAfterAll:
-  Description: Check that before/after(:all) isn't being used.
+  Description: Check that before/after(:all/:context) isn't being used.
   Enabled: true
   Exclude:
-  - spec/spec_helper.rb
-  - spec/rails_helper.rb
-  - spec/support/**/*.rb
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll
+    - "**/spec/spec_helper.rb"
+    - "**/spec/rails_helper.rb"
+    - "**/spec/support/**/*.rb"
+  VersionAdded: '1.12'
+  VersionChanged: '2.23'
+  StyleGuide: https://rspec.rubystyle.guide/#avoid-hooks-with-context-scope
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll
+
+RSpec/ChangeByZero:
+  Description: Prefer negated matchers over `to change.by(0)`.
+  Enabled: true
+  VersionAdded: '2.11'
+  VersionChanged: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeByZero
+  NegatedMatcher: ~
+
+RSpec/ClassCheck:
+  Description: Enforces consistent use of `be_a` or `be_kind_of`.
+  StyleGuide: "#is-a-vs-kind-of"
+  Enabled: true
+  VersionAdded: '2.13'
+  EnforcedStyle: be_a
+  SupportedStyles:
+    - be_a
+    - be_kind_of
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ClassCheck
+
+RSpec/ContainExactly:
+  Description: Checks where `contain_exactly` is used.
+  Enabled: true
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContainExactly
 
 RSpec/ContextMethod:
   Description: "`context` should not be used for specifying methods."
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod
+  VersionAdded: '1.36'
+  StyleGuide: https://rspec.rubystyle.guide/#example-group-naming
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod
 
 RSpec/ContextWording:
   Description: Checks that `context` docstring starts with an allowed prefix.
   Enabled: true
   Prefixes:
-  - when
-  - with
-  - without
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording
+    - when
+    - with
+    - without
+  AllowedPatterns: []
+  VersionAdded: '1.20'
+  VersionChanged: '2.13'
+  StyleGuide: https://rspec.rubystyle.guide/#context-descriptions
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording
 
 RSpec/DescribeClass:
-  Description: Check that the first argument to the top level describe is a constant.
+  Description: Check that the first argument to the top-level describe is a constant.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass
+  Exclude:
+    - "**/spec/features/**/*"
+    - "**/spec/requests/**/*"
+    - "**/spec/routing/**/*"
+    - "**/spec/system/**/*"
+    - "**/spec/views/**/*"
+  IgnoredMetadata:
+    type:
+      - channel
+      - controller
+      - helper
+      - job
+      - mailer
+      - model
+      - request
+      - routing
+      - view
+      - feature
+      - system
+      - mailbox
+      - aruba
+      - task
+  VersionAdded: '1.0'
+  VersionChanged: '2.7'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass
 
 RSpec/DescribeMethod:
   Description: Checks that the second argument to `describe` specifies a method.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod
+  VersionAdded: '1.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod
 
 RSpec/DescribeSymbol:
   Description: Avoid describing symbols.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol
+  VersionAdded: '1.15'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol
 
 RSpec/DescribedClass:
   Description: Checks that tests use `described_class`.
-  SkipBlocks: false
   Enabled: true
+  SkipBlocks: false
   EnforcedStyle: described_class
   SupportedStyles:
-  - described_class
-  - explicit
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass
+    - described_class
+    - explicit
+  OnlyStaticConstants: true
+  SafeAutoCorrect: false
+  VersionAdded: '1.0'
+  VersionChanged: '2.27'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass
 
 RSpec/DescribedClassModuleWrapping:
   Description: Avoid opening modules and defining specs within them.
   Enabled: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping
+  VersionAdded: '1.37'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping
 
 RSpec/Dialect:
-  Description: This cop enforces custom RSpec dialects.
+  Description: Enforces custom RSpec dialects.
   Enabled: false
   PreferredMethods: {}
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect
+  VersionAdded: '1.33'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect
+
+RSpec/DuplicatedMetadata:
+  Description: Avoid duplicated metadata.
+  Enabled: true
+  VersionAdded: '2.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DuplicatedMetadata
 
 RSpec/EmptyExampleGroup:
   Description: Checks if an example group does not include any tests.
   Enabled: true
-  CustomIncludeMethods: []
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup
+  AutoCorrect: contextual
+  SafeAutoCorrect: false
+  VersionAdded: '1.7'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup
+
+RSpec/EmptyHook:
+  Description: Checks for empty before and after hooks.
+  Enabled: true
+  AutoCorrect: contextual
+  VersionAdded: '1.39'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyHook
 
 RSpec/EmptyLineAfterExample:
   Description: Checks if there is an empty line after example blocks.
   Enabled: true
   AllowConsecutiveOneLiners: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample
+  VersionAdded: '1.36'
+  StyleGuide: https://rspec.rubystyle.guide/#empty-lines-around-examples
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample
 
 RSpec/EmptyLineAfterExampleGroup:
   Description: Checks if there is an empty line after example group blocks.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup
+  VersionAdded: '1.27'
+  StyleGuide: https://rspec.rubystyle.guide/#empty-lines-between-describes
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup
 
 RSpec/EmptyLineAfterFinalLet:
   Description: Checks if there is an empty line after the last let block.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet
+  VersionAdded: '1.14'
+  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet
 
 RSpec/EmptyLineAfterHook:
   Description: Checks if there is an empty line after hook blocks.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook
+  VersionAdded: '1.27'
+  VersionChanged: '2.13'
+  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook
+  AllowConsecutiveOneLiners: true
 
 RSpec/EmptyLineAfterSubject:
   Description: Checks if there is an empty line after subject block.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject
+  VersionAdded: '1.14'
+  StyleGuide: https://rspec.rubystyle.guide/#empty-line-after-let
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject
+
+RSpec/EmptyMetadata:
+  Description: Avoid empty metadata hash.
+  Enabled: true
+  AutoCorrect: contextual
+  VersionAdded: '2.24'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyMetadata
+
+RSpec/EmptyOutput:
+  Description: Check that the `output` matcher is not called with an empty string.
+  Enabled: true
+  VersionAdded: '2.29'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyOutput
+
+RSpec/Eq:
+  Description: Use `eq` instead of `be ==` to compare objects.
+  Enabled: true
+  VersionAdded: '2.24'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Eq
 
 RSpec/ExampleLength:
   Description: Checks for long examples.
   Enabled: true
   Max: 5
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength
+  CountAsOne: []
+  VersionAdded: '1.5'
+  VersionChanged: '2.3'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength
 
 RSpec/ExampleWithoutDescription:
   Description: Checks for examples without a description.
   Enabled: true
   EnforcedStyle: always_allow
   SupportedStyles:
-  - always_allow
-  - single_line_only
-  - disallow
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription
+    - always_allow
+    - single_line_only
+    - disallow
+  VersionAdded: '1.22'
+  StyleGuide: https://rspec.rubystyle.guide/#it-and-specify
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription
 
 RSpec/ExampleWording:
   Description: Checks for common mistakes in example descriptions.
@@ -156,212 +415,353 @@ RSpec/ExampleWording:
     have: has
     HAVE: HAS
   IgnoredWords: []
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording
+  DisallowedExamples:
+    - works
+  VersionAdded: '1.0'
+  VersionChanged: '2.13'
+  StyleGuide: https://rspec.rubystyle.guide/#should-in-example-docstrings
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording
+
+RSpec/ExcessiveDocstringSpacing:
+  Description: Checks for excessive whitespace in example descriptions.
+  Enabled: true
+  VersionAdded: '2.5'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExcessiveDocstringSpacing
 
 RSpec/ExpectActual:
   Description: Checks for `expect(...)` calls containing literal values.
   Enabled: true
   Exclude:
-  - spec/routing/**/*
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual
+    - "**/spec/routing/**/*"
+  VersionAdded: '1.7'
+  VersionChanged: '2.23'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual
 
 RSpec/ExpectChange:
   Description: Checks for consistent style of change matcher.
   Enabled: true
   EnforcedStyle: method_call
   SupportedStyles:
-  - method_call
-  - block
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange
+    - method_call
+    - block
+  SafeAutoCorrect: false
+  VersionAdded: '1.22'
+  VersionChanged: '2.5'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange
 
 RSpec/ExpectInHook:
-  Enabled: true
   Description: Do not use `expect` in hooks such as `before`.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook
+  Enabled: true
+  VersionAdded: '1.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook
 
-RSpec/ExpectOutput:
-  Description: Checks for opportunities to use `expect { ... }.to output`.
+RSpec/ExpectInLet:
+  Description: Do not use `expect` in let.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput
+  VersionAdded: '2.30'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInLet
 
-RSpec/FilePath:
-  Description: Checks that spec file paths are consistent with the test subject.
+RSpec/ExpectOutput:
+  Description: Checks for opportunities to use `expect { ... }.to output`.
   Enabled: true
-  CustomTransform:
-    RuboCop: rubocop
-    RSpec: rspec
-  IgnoreMethods: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FilePath
+  VersionAdded: '1.10'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput
 
 RSpec/Focus:
   Description: Checks if examples are focused.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus
+  AutoCorrect: contextual
+  VersionAdded: '1.5'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus
 
 RSpec/HookArgument:
   Description: Checks the arguments passed to `before`, `around`, and `after`.
   Enabled: true
   EnforcedStyle: implicit
   SupportedStyles:
-  - implicit
-  - each
-  - example
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument
+    - implicit
+    - each
+    - example
+  VersionAdded: '1.7'
+  StyleGuide: https://rspec.rubystyle.guide/#redundant-beforeeach
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument
 
 RSpec/HooksBeforeExamples:
-  Enabled: true
   Description: Checks for before/around/after hooks that come after an example.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples
+  Enabled: true
+  AutoCorrect: contextual
+  VersionAdded: '1.29'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples
+
+RSpec/IdenticalEqualityAssertion:
+  Description: Checks for equality assertions with identical expressions on both sides.
+  Enabled: true
+  VersionAdded: '2.4'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IdenticalEqualityAssertion
 
 RSpec/ImplicitBlockExpectation:
   Description: Check that implicit block expectation syntax is not used.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation
+  VersionAdded: '1.35'
+  StyleGuide: https://rspec.rubystyle.guide/#implicit-block-expectations
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation
 
 RSpec/ImplicitExpect:
   Description: Check that a consistent implicit expectation style is used.
   Enabled: true
   EnforcedStyle: is_expected
   SupportedStyles:
-  - is_expected
-  - should
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect
+    - is_expected
+    - should
+  VersionAdded: '1.8'
+  StyleGuide: https://rspec.rubystyle.guide/#use-expect
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect
 
 RSpec/ImplicitSubject:
-  Enabled: true
   Description: Checks for usage of implicit subject (`is_expected` / `should`).
+  Enabled: true
   EnforcedStyle: single_line_only
   SupportedStyles:
-  - single_line_only
-  - single_statement_only
-  - disallow
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject
+    - single_line_only
+    - single_statement_only
+    - disallow
+    - require_implicit
+  VersionAdded: '1.29'
+  VersionChanged: '2.13'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject
+
+RSpec/IncludeExamples:
+  Description: Checks for usage of `include_examples`.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '3.6'
+  VersionChanged: "<<next>>"
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IncludeExamples
+
+RSpec/IndexedLet:
+  Description: Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+  Enabled: true
+  VersionAdded: '2.20'
+  VersionChanged: '2.23'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IndexedLet
+  Max: 1
+  AllowedIdentifiers: []
+  AllowedPatterns: []
 
 RSpec/InstanceSpy:
   Description: Checks for `instance_double` used with `have_received`.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy
+  VersionAdded: '1.12'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy
 
 RSpec/InstanceVariable:
   Description: Checks for instance variable usage in specs.
-  AssignmentOnly: false
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable
+  AssignmentOnly: false
+  VersionAdded: '1.0'
+  VersionChanged: '1.7'
+  StyleGuide: https://rspec.rubystyle.guide/#instance-variables
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable
 
-RSpec/InvalidPredicateMatcher:
-  Description: Checks invalid usage for predicate matcher.
+RSpec/IsExpectedSpecify:
+  Description: Check for `specify` with `is_expected` and one-liner expectations.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InvalidPredicateMatcher
+  VersionAdded: '2.27'
+  StyleGuide: https://rspec.rubystyle.guide/#it-and-specify
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IsExpectedSpecify
 
 RSpec/ItBehavesLike:
   Description: Checks that only one `it_behaves_like` style is used.
   Enabled: true
   EnforcedStyle: it_behaves_like
   SupportedStyles:
-  - it_behaves_like
-  - it_should_behave_like
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike
+    - it_behaves_like
+    - it_should_behave_like
+  VersionAdded: '1.13'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike
 
 RSpec/IteratedExpectation:
   Description: Check that `all` matcher is used instead of iterating over an array.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation
+  VersionAdded: '1.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation
 
 RSpec/LeadingSubject:
   Description: Enforce that subject is the first definition in the test.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject
+  VersionAdded: '1.7'
+  VersionChanged: '1.14'
+  StyleGuide: https://rspec.rubystyle.guide/#leading-subject
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject
 
 RSpec/LeakyConstantDeclaration:
   Description: Checks that no class, module, or constant is declared.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration
+  VersionAdded: '1.35'
+  StyleGuide: https://rspec.rubystyle.guide/#declare-constants
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration
 
 RSpec/LetBeforeExamples:
   Description: Checks for `let` definitions that come after an example.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples
+  AutoCorrect: contextual
+  VersionAdded: '1.16'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples
 
 RSpec/LetSetup:
   Description: Checks unreferenced `let!` calls being used for test setup.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup
+  VersionAdded: '1.7'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup
+
+RSpec/MatchArray:
+  Description: Checks where `match_array` is used.
+  Enabled: true
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MatchArray
 
 RSpec/MessageChain:
   Description: Check that chains of messages are not being stubbed.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain
+  VersionAdded: '1.7'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain
 
 RSpec/MessageExpectation:
   Description: Checks for consistent message expectation style.
   Enabled: false
   EnforcedStyle: allow
   SupportedStyles:
-  - allow
-  - expect
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation
+    - allow
+    - expect
+  VersionAdded: '1.7'
+  VersionChanged: '1.8'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation
 
 RSpec/MessageSpies:
   Description: Checks that message expectations are set using spies.
   Enabled: true
   EnforcedStyle: have_received
   SupportedStyles:
-  - have_received
-  - receive
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies
+    - have_received
+    - receive
+  VersionAdded: '1.9'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies
+
+RSpec/MetadataStyle:
+  Description: Use consistent metadata style.
+  Enabled: true
+  EnforcedStyle: symbol
+  SupportedStyles:
+    - hash
+    - symbol
+  VersionAdded: '2.24'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MetadataStyle
 
 RSpec/MissingExampleGroupArgument:
   Description: Checks that the first argument to an example group is not empty.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument
+  VersionAdded: '1.28'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument
+
+RSpec/MissingExpectationTargetMethod:
+  Description: Checks if `.to`, `not_to` or `to_not` are used.
+  Enabled: true
+  VersionAdded: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExpectationTargetMethod
 
 RSpec/MultipleDescribes:
-  Description: Checks for multiple top level describes.
+  Description: Checks for multiple top-level example groups.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes
+  VersionAdded: '1.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes
 
 RSpec/MultipleExpectations:
   Description: Checks if examples contain too many `expect` calls.
   Enabled: true
   Max: 1
-  AggregateFailuresByDefault: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations
+  VersionAdded: '1.7'
+  VersionChanged: '1.21'
+  StyleGuide: https://rspec.rubystyle.guide/#expectation-per-example
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations
+
+RSpec/MultipleMemoizedHelpers:
+  Description: Checks if example groups contain too many `let` and `subject` calls.
+  Enabled: true
+  AllowSubject: true
+  Max: 5
+  VersionAdded: '1.43'
+  StyleGuide: https://rspec.rubystyle.guide/#let-blocks
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleMemoizedHelpers
 
 RSpec/MultipleSubjects:
   Description: Checks if an example group defines `subject` multiple times.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects
+  VersionAdded: '1.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects
 
 RSpec/NamedSubject:
   Description: Checks for explicitly referenced test subjects.
   Enabled: true
+  EnforcedStyle: always
+  SupportedStyles:
+    - always
+    - named_only
   IgnoreSharedExamples: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject
+  VersionAdded: 1.5.3
+  VersionChanged: '2.15'
+  StyleGuide: https://rspec.rubystyle.guide/#use-subject
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject
 
 RSpec/NestedGroups:
   Description: Checks for nested example groups.
   Enabled: true
   Max: 3
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups
+  AllowedGroups: []
+  VersionAdded: '1.7'
+  VersionChanged: '2.13'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups
+
+RSpec/NoExpectationExample:
+  Description: Checks if an example contains any expectation.
+  Enabled: true
+  Safe: false
+  VersionAdded: '2.13'
+  VersionChanged: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NoExpectationExample
+  AllowedPatterns:
+    - "^expect_"
+    - "^assert_"
 
 RSpec/NotToNot:
   Description: Checks for consistent method usage for negating expectations.
+  Enabled: true
   EnforcedStyle: not_to
   SupportedStyles:
-  - not_to
-  - to_not
-  Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot
+    - not_to
+    - to_not
+  VersionAdded: '1.4'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot
 
 RSpec/OverwritingSetup:
-  Enabled: true
   Description: Checks if there is a let/subject that overwrites an existing one.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup
+  Enabled: true
+  VersionAdded: '1.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup
 
 RSpec/Pending:
-  Enabled: false
   Description: Checks for any pending or skipped examples.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending
+  Enabled: false
+  VersionAdded: '1.25'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending
+
+RSpec/PendingWithoutReason:
+  Description: Checks for pending or skipped examples without reason.
+  Enabled: true
+  VersionAdded: '2.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PendingWithoutReason
 
 RSpec/PredicateMatcher:
   Description: Prefer using predicate matcher over using predicate method directly.
@@ -370,136 +770,254 @@ RSpec/PredicateMatcher:
   EnforcedStyle: inflected
   AllowedExplicitMatchers: []
   SupportedStyles:
-  - inflected
-  - explicit
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher
+    - inflected
+    - explicit
+  SafeAutoCorrect: false
+  VersionAdded: '1.16'
+  StyleGuide: https://rspec.rubystyle.guide/#predicate-matchers
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher
 
 RSpec/ReceiveCounts:
-  Enabled: true
   Description: Check for `once` and `twice` receive counts matchers usage.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts
+  Enabled: true
+  VersionAdded: '1.26'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts
 
-RSpec/ReceiveNever:
+RSpec/ReceiveMessages:
+  Description: Prefer `receive_messages` over multiple `receive`s on the same object.
   Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '2.23'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveMessages
+
+RSpec/ReceiveNever:
   Description: Prefer `not_to receive(...)` over `receive(...).never`.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever
+  Enabled: true
+  VersionAdded: '1.28'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever
 
-RSpec/RepeatedDescription:
+RSpec/RedundantAround:
+  Description: Remove redundant `around` hook.
   Enabled: true
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RedundantAround
+
+RSpec/RedundantPredicateMatcher:
+  Description: Checks for redundant predicate matcher.
+  Enabled: true
+  VersionAdded: '2.26'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RedundantPredicateMatcher
+
+RSpec/RemoveConst:
+  Description: Checks that `remove_const` is not used in specs.
+  Enabled: true
+  VersionAdded: '2.26'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RemoveConst
+
+RSpec/RepeatedDescription:
   Description: Check for repeated description strings in example groups.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription
+  Enabled: true
+  VersionAdded: '1.9'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription
 
 RSpec/RepeatedExample:
-  Enabled: true
   Description: Check for repeated examples within example groups.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample
+  Enabled: true
+  VersionAdded: '1.10'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample
 
 RSpec/RepeatedExampleGroupBody:
-  Enabled: true
   Description: Check for repeated describe and context block body.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody
+  Enabled: true
+  VersionAdded: '1.38'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody
 
 RSpec/RepeatedExampleGroupDescription:
-  Enabled: true
   Description: Check for repeated example group descriptions.
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription
+  Enabled: true
+  VersionAdded: '1.38'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription
 
-RSpec/ReturnFromStub:
+RSpec/RepeatedIncludeExample:
+  Description: Check for repeated include of shared examples.
+  Enabled: true
+  VersionAdded: '1.44'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedIncludeExample
+
+RSpec/RepeatedSubjectCall:
+  Description: Checks for repeated calls to subject missing that it is memoized.
   Enabled: true
+  VersionAdded: '2.27'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedSubjectCall
+
+RSpec/ReturnFromStub:
   Description: Checks for consistent style of stub's return setting.
+  Enabled: true
   EnforcedStyle: and_return
   SupportedStyles:
-  - and_return
-  - block
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub
+    - and_return
+    - block
+  VersionAdded: '1.16'
+  VersionChanged: '1.22'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub
 
 RSpec/ScatteredLet:
   Description: Checks for let scattered across the example group.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet
+  AutoCorrect: contextual
+  VersionAdded: '1.14'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet
 
 RSpec/ScatteredSetup:
   Description: Checks for setup scattered across multiple hooks in an example group.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup
+  AutoCorrect: contextual
+  VersionAdded: '1.10'
+  VersionChanged: '2.31'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup
 
 RSpec/SharedContext:
   Description: Checks for proper shared_context and shared_examples usage.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext
+  VersionAdded: '1.13'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext
 
 RSpec/SharedExamples:
-  Description: Enforces use of string to titleize shared examples.
+  Description: Checks for consistent style for shared example names.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples
+  EnforcedStyle: string
+  SupportedStyles:
+    - string
+    - symbol
+  VersionAdded: '1.25'
+  VersionChanged: '2.26'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples
 
 RSpec/SingleArgumentMessageChain:
   Description: Checks that chains of messages contain more than one element.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain
+  VersionAdded: '1.9'
+  VersionChanged: '1.10'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain
 
-RSpec/SubjectStub:
-  Description: Checks for stubbed test subjects.
+RSpec/SkipBlockInsideExample:
+  Description: Checks for passing a block to `skip` within examples.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SkipBlockInsideExample
 
-RSpec/UnspecifiedException:
-  Description: Checks for a specified error in checking raised errors.
+RSpec/SortMetadata:
+  Description: Sort RSpec metadata alphabetically.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SortMetadata
 
-RSpec/VerifiedDoubles:
-  Description: Prefer using verifying doubles over normal doubles.
+RSpec/SpecFilePathFormat:
+  Description: Checks that spec file paths are consistent and well-formed.
   Enabled: true
-  IgnoreNameless: true
-  IgnoreSymbolicNames: false
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles
+  Include:
+    - "**/*_spec.rb"
+  Exclude:
+    - "**/spec/routing/**/*"
+  CustomTransform:
+    RuboCop: rubocop
+    RSpec: rspec
+  IgnoreMethods: false
+  IgnoreMetadata:
+    type: routing
+  VersionAdded: '2.24'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathFormat
 
-RSpec/VoidExpect:
-  Description: This cop checks void `expect()`.
+RSpec/SpecFilePathSuffix:
+  Description: Checks that spec file paths suffix are consistent and well-formed.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect
+  VersionAdded: '2.24'
+  Include:
+    - "**/*_spec*rb*"
+    - "**/spec/**/*"
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathSuffix
 
-RSpec/Yield:
-  Description: This cop checks for calling a block within a stub.
+RSpec/StubbedMock:
+  Description: Checks that message expectations do not have a configured response.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield
+  VersionAdded: '1.44'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/StubbedMock
 
-Capybara/CurrentPathExpectation:
-  Description: Checks that no expectations are set on Capybara's `current_path`.
+RSpec/SubjectDeclaration:
+  Description: Ensure that subject is defined using subject helper.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/CurrentPathExpectation
+  VersionAdded: '2.5'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectDeclaration
 
-Capybara/FeatureMethods:
-  Description: Checks for consistent method usage in feature specs.
+RSpec/SubjectStub:
+  Description: Checks for stubbed test subjects.
   Enabled: true
-  EnabledMethods: []
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods
+  VersionAdded: '1.7'
+  VersionChanged: '2.8'
+  StyleGuide: https://rspec.rubystyle.guide/#dont-stub-subject
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub
 
-FactoryBot/AttributeDefinedStatically:
-  Description: Always declare attribute values as blocks.
+RSpec/UndescriptiveLiteralsDescription:
+  Description: Description should be descriptive.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/AttributeDefinedStatically
+  VersionAdded: '2.29'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UndescriptiveLiteralsDescription
 
-FactoryBot/CreateList:
-  Description: Checks for create_list usage.
+RSpec/UnspecifiedException:
+  Description: Checks for a specified error in checking raised errors.
   Enabled: true
-  EnforcedStyle: create_list
-  SupportedStyles:
-  - create_list
-  - n_times
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/CreateList
+  VersionAdded: '1.30'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException
 
-FactoryBot/FactoryClassName:
-  Description: Use string value when setting the class attribute explicitly.
+RSpec/VariableDefinition:
+  Description: Checks that memoized helpers names are symbols or strings.
   Enabled: true
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/FactoryClassName
+  EnforcedStyle: symbols
+  SupportedStyles:
+    - symbols
+    - strings
+  VersionAdded: '1.40'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableDefinition
 
-Rails/HttpStatus:
-  Description: Enforces use of symbolic or numeric value to describe HTTP status.
+RSpec/VariableName:
+  Description: Checks that memoized helper names use the configured style.
   Enabled: true
-  EnforcedStyle: symbolic
+  EnforcedStyle: snake_case
   SupportedStyles:
-  - numeric
-  - symbolic
-  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HttpStatus
+    - snake_case
+    - camelCase
+  AllowedPatterns: []
+  VersionAdded: '1.40'
+  VersionChanged: '2.13'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableName
+
+RSpec/VerifiedDoubleReference:
+  Description: Checks for consistent verified double reference style.
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: 2.10.0
+  VersionChanged: '3.4'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubleReference
+
+RSpec/VerifiedDoubles:
+  Description: Prefer using verifying doubles over normal doubles.
+  Enabled: true
+  IgnoreNameless: true
+  IgnoreSymbolicNames: false
+  VersionAdded: 1.2.1
+  VersionChanged: '1.5'
+  StyleGuide: https://rspec.rubystyle.guide/#doubles
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles
+
+RSpec/VoidExpect:
+  Description: Checks void `expect()`.
+  Enabled: true
+  VersionAdded: '1.16'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect
+
+RSpec/Yield:
+  Description: Checks for calling a block within a stub.
+  Enabled: true
+  VersionAdded: '1.32'
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield
diff --git a/config/obsoletion.yml b/config/obsoletion.yml
new file mode 100644
index 000000000..2c2442805
--- /dev/null
+++ b/config/obsoletion.yml
@@ -0,0 +1,35 @@
+#
+# Configuration of obsolete/deprecated cops used by `ConfigObsoletion`.
+#
+# See: https://docs.rubocop.org/rubocop/extensions.html#config-obsoletions
+#
+
+# Cop parameters that have been changed
+# Can be treated as a warning instead of a failure with `severity: warning`
+changed_parameters:
+  - cops:
+      - RSpec/VariableName
+    parameters: IgnoredPatterns
+    alternative: AllowedPatterns
+    severity: warning
+  - cops: RSpec/VerifiedDoubleReference
+    parameters: EnforcedStyle
+    reason: String references are not verifying unless the class is loaded.
+
+split:
+  RSpec/FilePath:
+    alternatives:
+      - RSpec/SpecFilePathFormat
+      - RSpec/SpecFilePathSuffix
+
+removed:
+  RSpec/Capybara/FeatureMethods:
+    reason: >
+      this cop has migrated to `RSpec/Dialect`. Please use `RSpec/Dialect` instead
+  RSpec/StringAsInstanceDoubleConstant:
+    reason: Please use `RSpec/VerifiedDoubleReference` instead
+
+extracted:
+  RSpec/Rails/*: rubocop-rspec_rails
+  RSpec/FactoryBot/*: rubocop-factory_bot
+  RSpec/Capybara/*: rubocop-capybara
diff --git a/docs/antora.yml b/docs/antora.yml
new file mode 100644
index 000000000..51a533a15
--- /dev/null
+++ b/docs/antora.yml
@@ -0,0 +1,5 @@
+name: rubocop-rspec
+title: RuboCop RSpec
+version: ~
+nav:
+  - modules/ROOT/nav.adoc
diff --git a/docs/modules/ROOT/nav.adoc b/docs/modules/ROOT/nav.adoc
new file mode 100644
index 000000000..2ab1a89d1
--- /dev/null
+++ b/docs/modules/ROOT/nav.adoc
@@ -0,0 +1,10 @@
+* xref:index.adoc[Home]
+* xref:installation.adoc[Installation]
+* xref:usage.adoc[Usage]
+* xref:cops.adoc[Cops]
+* xref:upgrade_to_version_2.adoc[Upgrade to 2.x]
+* xref:upgrade_to_version_3.adoc[Upgrade to 3.x]
+* xref:third_party_rspec_syntax_extensions.adoc[RSpec syntax extensions in third-party gems]
+* xref:development.adoc[Development]
+* Cops Documentation
+** xref:cops_rspec.adoc[RSpec]
diff --git a/docs/modules/ROOT/pages/cops.adoc b/docs/modules/ROOT/pages/cops.adoc
new file mode 100644
index 000000000..08329092b
--- /dev/null
+++ b/docs/modules/ROOT/pages/cops.adoc
@@ -0,0 +1,117 @@
+// START_COP_LIST
+
+=== Department xref:cops_rspec.adoc[RSpec]
+
+* xref:cops_rspec.adoc#rspecalignleftletbrace[RSpec/AlignLeftLetBrace]
+* xref:cops_rspec.adoc#rspecalignrightletbrace[RSpec/AlignRightLetBrace]
+* xref:cops_rspec.adoc#rspecanyinstance[RSpec/AnyInstance]
+* xref:cops_rspec.adoc#rspecaroundblock[RSpec/AroundBlock]
+* xref:cops_rspec.adoc#rspecbe[RSpec/Be]
+* xref:cops_rspec.adoc#rspecbeempty[RSpec/BeEmpty]
+* xref:cops_rspec.adoc#rspecbeeq[RSpec/BeEq]
+* xref:cops_rspec.adoc#rspecbeeql[RSpec/BeEql]
+* xref:cops_rspec.adoc#rspecbenil[RSpec/BeNil]
+* xref:cops_rspec.adoc#rspecbeforeafterall[RSpec/BeforeAfterAll]
+* xref:cops_rspec.adoc#rspecchangebyzero[RSpec/ChangeByZero]
+* xref:cops_rspec.adoc#rspecclasscheck[RSpec/ClassCheck]
+* xref:cops_rspec.adoc#rspeccontainexactly[RSpec/ContainExactly]
+* xref:cops_rspec.adoc#rspeccontextmethod[RSpec/ContextMethod]
+* xref:cops_rspec.adoc#rspeccontextwording[RSpec/ContextWording]
+* xref:cops_rspec.adoc#rspecdescribeclass[RSpec/DescribeClass]
+* xref:cops_rspec.adoc#rspecdescribemethod[RSpec/DescribeMethod]
+* xref:cops_rspec.adoc#rspecdescribesymbol[RSpec/DescribeSymbol]
+* xref:cops_rspec.adoc#rspecdescribedclass[RSpec/DescribedClass]
+* xref:cops_rspec.adoc#rspecdescribedclassmodulewrapping[RSpec/DescribedClassModuleWrapping]
+* xref:cops_rspec.adoc#rspecdialect[RSpec/Dialect]
+* xref:cops_rspec.adoc#rspecduplicatedmetadata[RSpec/DuplicatedMetadata]
+* xref:cops_rspec.adoc#rspecemptyexamplegroup[RSpec/EmptyExampleGroup]
+* xref:cops_rspec.adoc#rspecemptyhook[RSpec/EmptyHook]
+* xref:cops_rspec.adoc#rspecemptylineafterexample[RSpec/EmptyLineAfterExample]
+* xref:cops_rspec.adoc#rspecemptylineafterexamplegroup[RSpec/EmptyLineAfterExampleGroup]
+* xref:cops_rspec.adoc#rspecemptylineafterfinallet[RSpec/EmptyLineAfterFinalLet]
+* xref:cops_rspec.adoc#rspecemptylineafterhook[RSpec/EmptyLineAfterHook]
+* xref:cops_rspec.adoc#rspecemptylineaftersubject[RSpec/EmptyLineAfterSubject]
+* xref:cops_rspec.adoc#rspecemptymetadata[RSpec/EmptyMetadata]
+* xref:cops_rspec.adoc#rspecemptyoutput[RSpec/EmptyOutput]
+* xref:cops_rspec.adoc#rspeceq[RSpec/Eq]
+* xref:cops_rspec.adoc#rspecexamplelength[RSpec/ExampleLength]
+* xref:cops_rspec.adoc#rspecexamplewithoutdescription[RSpec/ExampleWithoutDescription]
+* xref:cops_rspec.adoc#rspecexamplewording[RSpec/ExampleWording]
+* xref:cops_rspec.adoc#rspecexcessivedocstringspacing[RSpec/ExcessiveDocstringSpacing]
+* xref:cops_rspec.adoc#rspecexpectactual[RSpec/ExpectActual]
+* xref:cops_rspec.adoc#rspecexpectchange[RSpec/ExpectChange]
+* xref:cops_rspec.adoc#rspecexpectinhook[RSpec/ExpectInHook]
+* xref:cops_rspec.adoc#rspecexpectinlet[RSpec/ExpectInLet]
+* xref:cops_rspec.adoc#rspecexpectoutput[RSpec/ExpectOutput]
+* xref:cops_rspec.adoc#rspecfocus[RSpec/Focus]
+* xref:cops_rspec.adoc#rspechookargument[RSpec/HookArgument]
+* xref:cops_rspec.adoc#rspechooksbeforeexamples[RSpec/HooksBeforeExamples]
+* xref:cops_rspec.adoc#rspecidenticalequalityassertion[RSpec/IdenticalEqualityAssertion]
+* xref:cops_rspec.adoc#rspecimplicitblockexpectation[RSpec/ImplicitBlockExpectation]
+* xref:cops_rspec.adoc#rspecimplicitexpect[RSpec/ImplicitExpect]
+* xref:cops_rspec.adoc#rspecimplicitsubject[RSpec/ImplicitSubject]
+* xref:cops_rspec.adoc#rspecincludeexamples[RSpec/IncludeExamples]
+* xref:cops_rspec.adoc#rspecindexedlet[RSpec/IndexedLet]
+* xref:cops_rspec.adoc#rspecinstancespy[RSpec/InstanceSpy]
+* xref:cops_rspec.adoc#rspecinstancevariable[RSpec/InstanceVariable]
+* xref:cops_rspec.adoc#rspecisexpectedspecify[RSpec/IsExpectedSpecify]
+* xref:cops_rspec.adoc#rspecitbehaveslike[RSpec/ItBehavesLike]
+* xref:cops_rspec.adoc#rspeciteratedexpectation[RSpec/IteratedExpectation]
+* xref:cops_rspec.adoc#rspecleadingsubject[RSpec/LeadingSubject]
+* xref:cops_rspec.adoc#rspecleakyconstantdeclaration[RSpec/LeakyConstantDeclaration]
+* xref:cops_rspec.adoc#rspecletbeforeexamples[RSpec/LetBeforeExamples]
+* xref:cops_rspec.adoc#rspecletsetup[RSpec/LetSetup]
+* xref:cops_rspec.adoc#rspecmatcharray[RSpec/MatchArray]
+* xref:cops_rspec.adoc#rspecmessagechain[RSpec/MessageChain]
+* xref:cops_rspec.adoc#rspecmessageexpectation[RSpec/MessageExpectation]
+* xref:cops_rspec.adoc#rspecmessagespies[RSpec/MessageSpies]
+* xref:cops_rspec.adoc#rspecmetadatastyle[RSpec/MetadataStyle]
+* xref:cops_rspec.adoc#rspecmissingexamplegroupargument[RSpec/MissingExampleGroupArgument]
+* xref:cops_rspec.adoc#rspecmissingexpectationtargetmethod[RSpec/MissingExpectationTargetMethod]
+* xref:cops_rspec.adoc#rspecmultipledescribes[RSpec/MultipleDescribes]
+* xref:cops_rspec.adoc#rspecmultipleexpectations[RSpec/MultipleExpectations]
+* xref:cops_rspec.adoc#rspecmultiplememoizedhelpers[RSpec/MultipleMemoizedHelpers]
+* xref:cops_rspec.adoc#rspecmultiplesubjects[RSpec/MultipleSubjects]
+* xref:cops_rspec.adoc#rspecnamedsubject[RSpec/NamedSubject]
+* xref:cops_rspec.adoc#rspecnestedgroups[RSpec/NestedGroups]
+* xref:cops_rspec.adoc#rspecnoexpectationexample[RSpec/NoExpectationExample]
+* xref:cops_rspec.adoc#rspecnottonot[RSpec/NotToNot]
+* xref:cops_rspec.adoc#rspecoverwritingsetup[RSpec/OverwritingSetup]
+* xref:cops_rspec.adoc#rspecpending[RSpec/Pending]
+* xref:cops_rspec.adoc#rspecpendingwithoutreason[RSpec/PendingWithoutReason]
+* xref:cops_rspec.adoc#rspecpredicatematcher[RSpec/PredicateMatcher]
+* xref:cops_rspec.adoc#rspecreceivecounts[RSpec/ReceiveCounts]
+* xref:cops_rspec.adoc#rspecreceivemessages[RSpec/ReceiveMessages]
+* xref:cops_rspec.adoc#rspecreceivenever[RSpec/ReceiveNever]
+* xref:cops_rspec.adoc#rspecredundantaround[RSpec/RedundantAround]
+* xref:cops_rspec.adoc#rspecredundantpredicatematcher[RSpec/RedundantPredicateMatcher]
+* xref:cops_rspec.adoc#rspecremoveconst[RSpec/RemoveConst]
+* xref:cops_rspec.adoc#rspecrepeateddescription[RSpec/RepeatedDescription]
+* xref:cops_rspec.adoc#rspecrepeatedexample[RSpec/RepeatedExample]
+* xref:cops_rspec.adoc#rspecrepeatedexamplegroupbody[RSpec/RepeatedExampleGroupBody]
+* xref:cops_rspec.adoc#rspecrepeatedexamplegroupdescription[RSpec/RepeatedExampleGroupDescription]
+* xref:cops_rspec.adoc#rspecrepeatedincludeexample[RSpec/RepeatedIncludeExample]
+* xref:cops_rspec.adoc#rspecrepeatedsubjectcall[RSpec/RepeatedSubjectCall]
+* xref:cops_rspec.adoc#rspecreturnfromstub[RSpec/ReturnFromStub]
+* xref:cops_rspec.adoc#rspecscatteredlet[RSpec/ScatteredLet]
+* xref:cops_rspec.adoc#rspecscatteredsetup[RSpec/ScatteredSetup]
+* xref:cops_rspec.adoc#rspecsharedcontext[RSpec/SharedContext]
+* xref:cops_rspec.adoc#rspecsharedexamples[RSpec/SharedExamples]
+* xref:cops_rspec.adoc#rspecsingleargumentmessagechain[RSpec/SingleArgumentMessageChain]
+* xref:cops_rspec.adoc#rspecskipblockinsideexample[RSpec/SkipBlockInsideExample]
+* xref:cops_rspec.adoc#rspecsortmetadata[RSpec/SortMetadata]
+* xref:cops_rspec.adoc#rspecspecfilepathformat[RSpec/SpecFilePathFormat]
+* xref:cops_rspec.adoc#rspecspecfilepathsuffix[RSpec/SpecFilePathSuffix]
+* xref:cops_rspec.adoc#rspecstubbedmock[RSpec/StubbedMock]
+* xref:cops_rspec.adoc#rspecsubjectdeclaration[RSpec/SubjectDeclaration]
+* xref:cops_rspec.adoc#rspecsubjectstub[RSpec/SubjectStub]
+* xref:cops_rspec.adoc#rspecundescriptiveliteralsdescription[RSpec/UndescriptiveLiteralsDescription]
+* xref:cops_rspec.adoc#rspecunspecifiedexception[RSpec/UnspecifiedException]
+* xref:cops_rspec.adoc#rspecvariabledefinition[RSpec/VariableDefinition]
+* xref:cops_rspec.adoc#rspecvariablename[RSpec/VariableName]
+* xref:cops_rspec.adoc#rspecverifieddoublereference[RSpec/VerifiedDoubleReference]
+* xref:cops_rspec.adoc#rspecverifieddoubles[RSpec/VerifiedDoubles]
+* xref:cops_rspec.adoc#rspecvoidexpect[RSpec/VoidExpect]
+* xref:cops_rspec.adoc#rspecyield[RSpec/Yield]
+
+// END_COP_LIST
diff --git a/docs/modules/ROOT/pages/cops_rspec.adoc b/docs/modules/ROOT/pages/cops_rspec.adoc
new file mode 100644
index 000000000..40c7757ac
--- /dev/null
+++ b/docs/modules/ROOT/pages/cops_rspec.adoc
@@ -0,0 +1,6610 @@
+////
+  Do NOT edit this file by hand directly, as it is automatically generated.
+
+  Please make any necessary changes to the cop documentation within the source files themselves.
+////
+
+= RSpec
+
+[#rspecalignleftletbrace]
+== RSpec/AlignLeftLetBrace
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| Always
+| 1.16
+| -
+|===
+
+Checks that left braces for adjacent single line lets are aligned.
+
+[#examples-rspecalignleftletbrace]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foobar) { blahblah }
+let(:baz) { bar }
+let(:a) { b }
+
+# good
+let(:foobar) { blahblah }
+let(:baz)    { bar }
+let(:a)      { b }
+----
+
+[#references-rspecalignleftletbrace]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace
+
+[#rspecalignrightletbrace]
+== RSpec/AlignRightLetBrace
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| Always
+| 1.16
+| -
+|===
+
+Checks that right braces for adjacent single line lets are aligned.
+
+[#examples-rspecalignrightletbrace]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foobar) { blahblah }
+let(:baz)    { bar }
+let(:a)      { b }
+
+# good
+let(:foobar) { blahblah }
+let(:baz)    { bar      }
+let(:a)      { b        }
+----
+
+[#references-rspecalignrightletbrace]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace
+
+[#rspecanyinstance]
+== RSpec/AnyInstance
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.4
+| -
+|===
+
+Check that instances are not being stubbed globally.
+
+Prefer instance doubles over stubbing any instance of a class
+
+[#examples-rspecanyinstance]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  before { allow_any_instance_of(MyClass).to receive(:foo) }
+end
+
+# good
+describe MyClass do
+  let(:my_instance) { instance_double(MyClass) }
+
+  before do
+    allow(MyClass).to receive(:new).and_return(my_instance)
+    allow(my_instance).to receive(:foo)
+  end
+end
+----
+
+[#references-rspecanyinstance]
+=== References
+
+* https://rspec.rubystyle.guide/#any_instance_of
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance
+
+[#rspecaroundblock]
+== RSpec/AroundBlock
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.11
+| -
+|===
+
+Checks that around blocks actually run the test.
+
+[#examples-rspecaroundblock]
+=== Examples
+
+[source,ruby]
+----
+# bad
+around do
+  some_method
+end
+
+around do |test|
+  some_method
+end
+
+# good
+around do |test|
+  some_method
+  test.call
+end
+
+around do |test|
+  some_method
+  test.run
+end
+----
+
+[#references-rspecaroundblock]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock
+
+[#rspecbe]
+== RSpec/Be
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.25
+| -
+|===
+
+Check for expectations where `be` is used without argument.
+
+The `be` matcher is too generic, as it pass on everything that is not
+nil or false. If that is the exact intend, use `be_truthy`. In all other
+cases it's better to specify what exactly is the expected value.
+
+[#examples-rspecbe]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to be
+
+# good
+expect(foo).to be_truthy
+expect(foo).to be 1.0
+expect(foo).to be(true)
+----
+
+[#references-rspecbe]
+=== References
+
+* https://rspec.rubystyle.guide/#be-matcher
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be
+
+[#rspecbeempty]
+== RSpec/BeEmpty
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 2.20
+| 2.31
+|===
+
+Prefer using `be_empty` when checking for an empty array.
+
+[#examples-rspecbeempty]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(array).to contain_exactly
+expect(array).to match_array([])
+
+# good
+expect(array).to be_empty
+----
+
+[#references-rspecbeempty]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEmpty
+
+[#rspecbeeq]
+== RSpec/BeEq
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| No
+| Always (Unsafe)
+| 2.9.0
+| 2.16
+|===
+
+Check for expectations where `be(...)` can replace `eq(...)`.
+
+The `be` matcher compares by identity while the `eq` matcher compares
+using `==`. Booleans and nil can be compared by identity and therefore
+the `be` matcher is preferable as it is a more strict test.
+
+[#safety-rspecbeeq]
+=== Safety
+
+This cop is unsafe because it changes how values are compared.
+
+[#examples-rspecbeeq]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to eq(true)
+expect(foo).to eq(false)
+expect(foo).to eq(nil)
+
+# good
+expect(foo).to be(true)
+expect(foo).to be(false)
+expect(foo).to be(nil)
+----
+
+[#references-rspecbeeq]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEq
+
+[#rspecbeeql]
+== RSpec/BeEql
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| No
+| Always (Unsafe)
+| 1.7
+| 2.16
+|===
+
+Check for expectations where `be(...)` can replace `eql(...)`.
+
+The `be` matcher compares by identity while the `eql` matcher
+compares using `eql?`. Integers, floats, booleans, symbols, and nil
+can be compared by identity and therefore the `be` matcher is
+preferable as it is a more strict test.
+
+This cop only looks for instances of `expect(...).to eql(...)`. We
+do not check `to_not` or `not_to` since `!eql?` is more strict
+than `!equal?`. We also do not try to flag `eq` because if
+`a == b`, and `b` is comparable by identity, `a` is still not
+necessarily the same type as `b` since the `#==` operator can
+coerce objects for comparison.
+
+[#safety-rspecbeeql]
+=== Safety
+
+This cop is unsafe because it changes how values are compared.
+
+[#examples-rspecbeeql]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to eql(1)
+expect(foo).to eql(1.0)
+expect(foo).to eql(true)
+expect(foo).to eql(false)
+expect(foo).to eql(:bar)
+expect(foo).to eql(nil)
+
+# good
+expect(foo).to be(1)
+expect(foo).to be(1.0)
+expect(foo).to be(true)
+expect(foo).to be(false)
+expect(foo).to be(:bar)
+expect(foo).to be(nil)
+----
+
+[#references-rspecbeeql]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql
+
+[#rspecbenil]
+== RSpec/BeNil
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.9.0
+| 2.10.0
+|===
+
+Ensures a consistent style is used when matching `nil`.
+
+You can either use the more specific `be_nil` matcher, or the more
+generic `be` matcher with a `nil` argument.
+
+This cop can be configured using the `EnforcedStyle` option
+
+[#examples-rspecbenil]
+=== Examples
+
+[#_enforcedstyle_-be_nil_-_default_-rspecbenil]
+==== `EnforcedStyle: be_nil` (default)
+
+[source,ruby]
+----
+# bad
+expect(foo).to be(nil)
+
+# good
+expect(foo).to be_nil
+----
+
+[#_enforcedstyle_-be_-rspecbenil]
+==== `EnforcedStyle: be`
+
+[source,ruby]
+----
+# bad
+expect(foo).to be_nil
+
+# good
+expect(foo).to be(nil)
+----
+
+[#configurable-attributes-rspecbenil]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `be_nil`
+| `be`, `be_nil`
+|===
+
+[#references-rspecbenil]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeNil
+
+[#rspecbeforeafterall]
+== RSpec/BeforeAfterAll
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.12
+| 2.23
+|===
+
+Check that before/after(:all/:context) isn't being used.
+
+[#examples-rspecbeforeafterall]
+=== Examples
+
+[source,ruby]
+----
+# bad - Faster but risk of state leaking between examples
+describe MyClass do
+  before(:all) { Widget.create }
+  after(:context) { Widget.delete_all }
+end
+
+# good - Slower but examples are properly isolated
+describe MyClass do
+  before(:each) { Widget.create }
+  after(:each) { Widget.delete_all }
+end
+----
+
+[#configurable-attributes-rspecbeforeafterall]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Exclude
+| `+**/spec/spec_helper.rb+`, `+**/spec/rails_helper.rb+`, `+**/spec/support/**/*.rb+`
+| Array
+|===
+
+[#references-rspecbeforeafterall]
+=== References
+
+* https://rspec.rubystyle.guide/#avoid-hooks-with-context-scope
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll
+
+[#rspecchangebyzero]
+== RSpec/ChangeByZero
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.11
+| 2.14
+|===
+
+Prefer negated matchers over `to change.by(0)`.
+
+In the case of composite expectations, cop suggest using the
+negation matchers of `RSpec::Matchers#change`.
+
+By default the cop does not support autocorrect of
+compound expectations, but if you set the
+negated matcher for `change`, e.g. `not_change` with
+the `NegatedMatcher` option, the cop will perform the autocorrection.
+
+[#examples-rspecchangebyzero]
+=== Examples
+
+[#negatedmatcher_-_-_default_-rspecchangebyzero]
+==== NegatedMatcher: ~ (default)
+
+[source,ruby]
+----
+# bad
+expect { run }.to change(Foo, :bar).by(0)
+expect { run }.to change { Foo.bar }.by(0)
+
+# bad - compound expectations (does not support autocorrection)
+expect { run }
+  .to change(Foo, :bar).by(0)
+  .and change(Foo, :baz).by(0)
+expect { run }
+  .to change { Foo.bar }.by(0)
+  .and change { Foo.baz }.by(0)
+
+# good
+expect { run }.not_to change(Foo, :bar)
+expect { run }.not_to change { Foo.bar }
+
+# good - compound expectations
+define_negated_matcher :not_change, :change
+expect { run }
+  .to not_change(Foo, :bar)
+  .and not_change(Foo, :baz)
+expect { run }
+  .to not_change { Foo.bar }
+  .and not_change { Foo.baz }
+----
+
+[#negatedmatcher_-not_change-rspecchangebyzero]
+==== NegatedMatcher: not_change
+
+[source,ruby]
+----
+# bad (support autocorrection to good case)
+expect { run }
+  .to change(Foo, :bar).by(0)
+  .and change(Foo, :baz).by(0)
+expect { run }
+  .to change { Foo.bar }.by(0)
+  .and change { Foo.baz }.by(0)
+
+# good
+define_negated_matcher :not_change, :change
+expect { run }
+  .to not_change(Foo, :bar)
+  .and not_change(Foo, :baz)
+expect { run }
+  .to not_change { Foo.bar }
+  .and not_change { Foo.baz }
+----
+
+[#configurable-attributes-rspecchangebyzero]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| NegatedMatcher
+| `<none>`
+| 
+|===
+
+[#references-rspecchangebyzero]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ChangeByZero
+
+[#rspecclasscheck]
+== RSpec/ClassCheck
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.13
+| -
+|===
+
+Enforces consistent use of `be_a` or `be_kind_of`.
+
+[#examples-rspecclasscheck]
+=== Examples
+
+[#enforcedstyle_-be_a-_default_-rspecclasscheck]
+==== EnforcedStyle: be_a (default)
+
+[source,ruby]
+----
+# bad
+expect(object).to be_kind_of(String)
+expect(object).to be_a_kind_of(String)
+
+# good
+expect(object).to be_a(String)
+expect(object).to be_an(String)
+----
+
+[#enforcedstyle_-be_kind_of-rspecclasscheck]
+==== EnforcedStyle: be_kind_of
+
+[source,ruby]
+----
+# bad
+expect(object).to be_a(String)
+expect(object).to be_an(String)
+
+# good
+expect(object).to be_kind_of(String)
+expect(object).to be_a_kind_of(String)
+----
+
+[#configurable-attributes-rspecclasscheck]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `be_a`
+| `be_a`, `be_kind_of`
+|===
+
+[#references-rspecclasscheck]
+=== References
+
+* https://rubystyle.guide#is-a-vs-kind-of
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ClassCheck
+
+[#rspeccontainexactly]
+== RSpec/ContainExactly
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.19
+| -
+|===
+
+Checks where `contain_exactly` is used.
+
+This cop checks for the following:
+
+- Prefer `match_array` when matching array values.
+- Prefer `be_empty` when using `contain_exactly` with no arguments.
+
+[#examples-rspeccontainexactly]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it { is_expected.to contain_exactly(*array1, *array2) }
+
+# good
+it { is_expected.to match_array(array1 + array2) }
+
+# good
+it { is_expected.to contain_exactly(content, *array) }
+----
+
+[#references-rspeccontainexactly]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContainExactly
+
+[#rspeccontextmethod]
+== RSpec/ContextMethod
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.36
+| -
+|===
+
+`context` should not be used for specifying methods.
+
+[#examples-rspeccontextmethod]
+=== Examples
+
+[source,ruby]
+----
+# bad
+context '#foo_bar' do
+  # ...
+end
+
+context '.foo_bar' do
+  # ...
+end
+
+# good
+describe '#foo_bar' do
+  # ...
+end
+
+describe '.foo_bar' do
+  # ...
+end
+----
+
+[#references-rspeccontextmethod]
+=== References
+
+* https://rspec.rubystyle.guide/#example-group-naming
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod
+
+[#rspeccontextwording]
+== RSpec/ContextWording
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.20
+| 2.13
+|===
+
+Checks that `context` docstring starts with an allowed prefix.
+
+The default list of prefixes is minimal. Users are encouraged to tailor
+the configuration to meet project needs. Other acceptable prefixes may
+include `if`, `unless`, `for`, `before`, `after`, or `during`.
+They may consist of multiple words if desired.
+
+If both `Prefixes` and `AllowedPatterns` are empty, this cop will always
+report an offense. So you need to set at least one of them.
+
+This cop can be customized allowed context description pattern
+with `AllowedPatterns`. By default, there are no checking by pattern.
+
+[#examples-rspeccontextwording]
+=== Examples
+
+[#_prefixes_-configuration-rspeccontextwording]
+==== `Prefixes` configuration
+
+[source,ruby]
+----
+# .rubocop.yml
+# RSpec/ContextWording:
+#   Prefixes:
+#     - when
+#     - with
+#     - without
+#     - if
+#     - unless
+#     - for
+----
+
+[source,ruby]
+----
+# bad
+context 'the display name not present' do
+  # ...
+end
+
+# good
+context 'when the display name is not present' do
+  # ...
+end
+----
+
+[#_allowedpatterns_-configuration-rspeccontextwording]
+==== `AllowedPatterns` configuration
+
+[source,ruby]
+----
+# .rubocop.yml
+# RSpec/ContextWording:
+#   AllowedPatterns:
+#     - とき$
+----
+
+[source,ruby]
+----
+# bad
+context '条件を満たす' do
+  # ...
+end
+
+# good
+context '条件を満たすとき' do
+  # ...
+end
+----
+
+[#configurable-attributes-rspeccontextwording]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Prefixes
+| `when`, `with`, `without`
+| Array
+
+| AllowedPatterns
+| `[]`
+| Array
+|===
+
+[#references-rspeccontextwording]
+=== References
+
+* https://rspec.rubystyle.guide/#context-descriptions
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording
+* http://www.betterspecs.org/#contexts
+
+[#rspecdescribeclass]
+== RSpec/DescribeClass
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.0
+| 2.7
+|===
+
+Check that the first argument to the top-level describe is a constant.
+
+It can be configured to ignore strings when certain metadata is passed.
+
+Ignores Rails and Aruba `type` metadata by default.
+
+[#examples-rspecdescribeclass]
+=== Examples
+
+[#_ignoredmetadata_-configuration-rspecdescribeclass]
+==== `IgnoredMetadata` configuration
+
+[source,ruby]
+----
+# .rubocop.yml
+# RSpec/DescribeClass:
+#   IgnoredMetadata:
+#     type:
+#       - request
+#       - controller
+----
+
+[source,ruby]
+----
+# bad
+describe 'Do something' do
+end
+
+# good
+describe TestedClass do
+  subject { described_class }
+end
+
+describe 'TestedClass::VERSION' do
+  subject { Object.const_get(self.class.description) }
+end
+
+describe "A feature example", type: :feature do
+end
+----
+
+[#configurable-attributes-rspecdescribeclass]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Exclude
+| `+**/spec/features/**/*+`, `+**/spec/requests/**/*+`, `+**/spec/routing/**/*+`, `+**/spec/system/**/*+`, `+**/spec/views/**/*+`
+| Array
+
+| IgnoredMetadata
+| `{"type" => ["channel", "controller", "helper", "job", "mailer", "model", "request", "routing", "view", "feature", "system", "mailbox", "aruba", "task"]}`
+| 
+|===
+
+[#references-rspecdescribeclass]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass
+
+[#rspecdescribemethod]
+== RSpec/DescribeMethod
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.0
+| -
+|===
+
+Checks that the second argument to `describe` specifies a method.
+
+[#examples-rspecdescribemethod]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass, 'do something' do
+end
+
+# good
+describe MyClass, '#my_instance_method' do
+end
+
+describe MyClass, '.my_class_method' do
+end
+----
+
+[#references-rspecdescribemethod]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod
+
+[#rspecdescribesymbol]
+== RSpec/DescribeSymbol
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.15
+| -
+|===
+
+Avoid describing symbols.
+
+[#examples-rspecdescribesymbol]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe :my_method do
+  # ...
+end
+
+# good
+describe '#my_method' do
+  # ...
+end
+----
+
+[#references-rspecdescribesymbol]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol
+* https://github.com/rspec/rspec-core/issues/1610
+
+[#rspecdescribedclass]
+== RSpec/DescribedClass
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always (Unsafe)
+| 1.0
+| 2.27
+|===
+
+Checks that tests use `described_class`.
+
+If the first argument of describe is a class, the class is exposed to
+each example via described_class.
+
+This cop can be configured using the `EnforcedStyle`, `SkipBlocks`
+and `OnlyStaticConstants` options.
+`OnlyStaticConstants` is only relevant when `EnforcedStyle` is
+`described_class`.
+
+There's a known caveat with rspec-rails's `controller` helper that
+runs its block in a different context, and `described_class` is not
+available to it. `SkipBlocks` option excludes detection in all
+non-RSpec related blocks.
+
+To narrow down this setting to only a specific directory, it is
+possible to use an overriding configuration file local to that
+directory.
+
+[#examples-rspecdescribedclass]
+=== Examples
+
+[#_enforcedstyle_-described_class_-_default_-rspecdescribedclass]
+==== `EnforcedStyle: described_class` (default)
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  subject { MyClass.do_something }
+end
+
+# good
+describe MyClass do
+  subject { described_class.do_something }
+end
+----
+
+[#_onlystaticconstants_-true_-_default_-rspecdescribedclass]
+==== `OnlyStaticConstants: true` (default)
+
+[source,ruby]
+----
+# good
+describe MyClass do
+  subject { MyClass::CONSTANT }
+end
+----
+
+[#_onlystaticconstants_-false_-rspecdescribedclass]
+==== `OnlyStaticConstants: false`
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  subject { MyClass::CONSTANT }
+end
+----
+
+[#_enforcedstyle_-explicit_-rspecdescribedclass]
+==== `EnforcedStyle: explicit`
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  subject { described_class.do_something }
+end
+
+# good
+describe MyClass do
+  subject { MyClass.do_something }
+end
+----
+
+[#_skipblocks_-true_-rspecdescribedclass]
+==== `SkipBlocks: true`
+
+[source,ruby]
+----
+# spec/controllers/.rubocop.yml
+# RSpec/DescribedClass:
+#   SkipBlocks: true
+
+# acceptable
+describe MyConcern do
+  controller(ApplicationController) do
+    include MyConcern
+  end
+end
+----
+
+[#configurable-attributes-rspecdescribedclass]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| SkipBlocks
+| `false`
+| Boolean
+
+| EnforcedStyle
+| `described_class`
+| `described_class`, `explicit`
+
+| OnlyStaticConstants
+| `true`
+| Boolean
+|===
+
+[#references-rspecdescribedclass]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass
+
+[#rspecdescribedclassmodulewrapping]
+== RSpec/DescribedClassModuleWrapping
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| No
+| 1.37
+| -
+|===
+
+Avoid opening modules and defining specs within them.
+
+[#examples-rspecdescribedclassmodulewrapping]
+=== Examples
+
+[source,ruby]
+----
+# bad
+module MyModule
+  RSpec.describe MyClass do
+    # ...
+  end
+end
+
+# good
+RSpec.describe MyModule::MyClass do
+  # ...
+end
+----
+
+[#references-rspecdescribedclassmodulewrapping]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping
+* https://github.com/rubocop/rubocop-rspec/issues/735
+
+[#rspecdialect]
+== RSpec/Dialect
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| Always
+| 1.33
+| -
+|===
+
+Enforces custom RSpec dialects.
+
+A dialect can be based on the following RSpec methods:
+
+- describe, context, feature, example_group
+- xdescribe, xcontext, xfeature
+- fdescribe, fcontext, ffeature
+- shared_examples, shared_examples_for, shared_context
+- it, specify, example, scenario, its
+- fit, fspecify, fexample, fscenario, focus
+- xit, xspecify, xexample, xscenario, skip
+- pending
+- prepend_before, before, append_before,
+- around
+- prepend_after, after, append_after
+- let, let!
+- subject, subject!
+- expect, is_expected, expect_any_instance_of
+
+By default all of the RSpec methods and aliases are allowed. By setting
+a config like:
+
+  RSpec/Dialect:
+    PreferredMethods:
+      context: describe
+
+If you were previously using the `RSpec/Capybara/FeatureMethods` cop and
+want to keep disabling all Capybara-specific methods that have the same
+native RSpec method (e.g. are just aliases), use the following config:
+
+  RSpec/Dialect:
+    PreferredMethods:
+      background: :before
+      scenario:   :it
+      xscenario:  :xit
+      given:      :let
+      given!:     :let!
+      feature:    :describe
+
+You can expect the following behavior:
+
+[#examples-rspecdialect]
+=== Examples
+
+[source,ruby]
+----
+# bad
+context 'display name presence' do
+  # ...
+end
+
+# good
+describe 'display name presence' do
+  # ...
+end
+----
+
+[#configurable-attributes-rspecdialect]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| PreferredMethods
+| `{}`
+| 
+|===
+
+[#references-rspecdialect]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect
+
+[#rspecduplicatedmetadata]
+== RSpec/DuplicatedMetadata
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.16
+| -
+|===
+
+Avoid duplicated metadata.
+
+[#examples-rspecduplicatedmetadata]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe 'Something', :a, :a
+
+# good
+describe 'Something', :a
+----
+
+[#references-rspecduplicatedmetadata]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DuplicatedMetadata
+
+[#rspecemptyexamplegroup]
+== RSpec/EmptyExampleGroup
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only (Unsafe)
+| 1.7
+| 2.31
+|===
+
+Checks if an example group does not include any tests.
+
+[#examples-rspecemptyexamplegroup]
+=== Examples
+
+[#usage-rspecemptyexamplegroup]
+==== usage
+
+[source,ruby]
+----
+# bad
+describe Bacon do
+  let(:bacon)      { Bacon.new(chunkiness) }
+  let(:chunkiness) { false                 }
+
+  context 'extra chunky' do   # flagged by rubocop
+    let(:chunkiness) { true }
+  end
+
+  it 'is chunky' do
+    expect(bacon.chunky?).to be_truthy
+  end
+end
+
+# good
+describe Bacon do
+  let(:bacon)      { Bacon.new(chunkiness) }
+  let(:chunkiness) { false                 }
+
+  it 'is chunky' do
+    expect(bacon.chunky?).to be_truthy
+  end
+end
+
+# good
+describe Bacon do
+  pending 'will add tests later'
+end
+----
+
+[#references-rspecemptyexamplegroup]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup
+
+[#rspecemptyhook]
+== RSpec/EmptyHook
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.39
+| 2.31
+|===
+
+Checks for empty before and after hooks.
+
+[#examples-rspecemptyhook]
+=== Examples
+
+[source,ruby]
+----
+# bad
+before {}
+after do; end
+before(:all) do
+end
+after(:all) { }
+
+# good
+before { create_users }
+after do
+  cleanup_users
+end
+before(:all) do
+  create_feed
+end
+after(:all) { cleanup_feed }
+----
+
+[#references-rspecemptyhook]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyHook
+
+[#rspecemptylineafterexample]
+== RSpec/EmptyLineAfterExample
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.36
+| -
+|===
+
+Checks if there is an empty line after example blocks.
+
+[#examples-rspecemptylineafterexample]
+=== Examples
+
+[source,ruby]
+----
+# bad
+RSpec.describe Foo do
+  it 'does this' do
+  end
+  it 'does that' do
+  end
+end
+
+# good
+RSpec.describe Foo do
+  it 'does this' do
+  end
+
+  it 'does that' do
+  end
+end
+
+# fair - it's ok to have non-separated one-liners
+RSpec.describe Foo do
+  it { one }
+  it { two }
+end
+----
+
+[#with-allowconsecutiveoneliners-configuration-rspecemptylineafterexample]
+==== with AllowConsecutiveOneLiners configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/EmptyLineAfterExample:
+#   AllowConsecutiveOneLiners: false
+
+# bad
+RSpec.describe Foo do
+  it { one }
+  it { two }
+end
+----
+
+[#configurable-attributes-rspecemptylineafterexample]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| AllowConsecutiveOneLiners
+| `true`
+| Boolean
+|===
+
+[#references-rspecemptylineafterexample]
+=== References
+
+* https://rspec.rubystyle.guide/#empty-lines-around-examples
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample
+
+[#rspecemptylineafterexamplegroup]
+== RSpec/EmptyLineAfterExampleGroup
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.27
+| -
+|===
+
+Checks if there is an empty line after example group blocks.
+
+[#examples-rspecemptylineafterexamplegroup]
+=== Examples
+
+[source,ruby]
+----
+# bad
+RSpec.describe Foo do
+  describe '#bar' do
+  end
+  describe '#baz' do
+  end
+end
+
+# good
+RSpec.describe Foo do
+  describe '#bar' do
+  end
+
+  describe '#baz' do
+  end
+end
+----
+
+[#references-rspecemptylineafterexamplegroup]
+=== References
+
+* https://rspec.rubystyle.guide/#empty-lines-between-describes
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup
+
+[#rspecemptylineafterfinallet]
+== RSpec/EmptyLineAfterFinalLet
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.14
+| -
+|===
+
+Checks if there is an empty line after the last let block.
+
+[#examples-rspecemptylineafterfinallet]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) { bar }
+let(:something) { other }
+it { does_something }
+
+# good
+let(:foo) { bar }
+let(:something) { other }
+
+it { does_something }
+----
+
+[#references-rspecemptylineafterfinallet]
+=== References
+
+* https://rspec.rubystyle.guide/#empty-line-after-let
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet
+
+[#rspecemptylineafterhook]
+== RSpec/EmptyLineAfterHook
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.27
+| 2.13
+|===
+
+Checks if there is an empty line after hook blocks.
+
+`AllowConsecutiveOneLiners` configures whether adjacent
+one-line definitions are considered an offense.
+
+[#examples-rspecemptylineafterhook]
+=== Examples
+
+[source,ruby]
+----
+# bad
+before { do_something }
+it { does_something }
+
+# bad
+after { do_something }
+it { does_something }
+
+# bad
+around { |test| test.run }
+it { does_something }
+
+# good
+after { do_something }
+
+it { does_something }
+
+# fair - it's ok to have non-separated one-liners hooks
+around { |test| test.run }
+after { do_something }
+
+it { does_something }
+----
+
+[#with-allowconsecutiveoneliners-configuration-rspecemptylineafterhook]
+==== with AllowConsecutiveOneLiners configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/EmptyLineAfterHook:
+#   AllowConsecutiveOneLiners: false
+
+# bad
+around { |test| test.run }
+after { do_something }
+
+it { does_something }
+
+# good
+around { |test| test.run }
+
+after { do_something }
+
+it { does_something }
+----
+
+[#configurable-attributes-rspecemptylineafterhook]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| AllowConsecutiveOneLiners
+| `true`
+| Boolean
+|===
+
+[#references-rspecemptylineafterhook]
+=== References
+
+* https://rspec.rubystyle.guide/#empty-line-after-let
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook
+
+[#rspecemptylineaftersubject]
+== RSpec/EmptyLineAfterSubject
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.14
+| -
+|===
+
+Checks if there is an empty line after subject block.
+
+[#examples-rspecemptylineaftersubject]
+=== Examples
+
+[source,ruby]
+----
+# bad
+subject(:obj) { described_class }
+let(:foo) { bar }
+
+# good
+subject(:obj) { described_class }
+
+let(:foo) { bar }
+----
+
+[#references-rspecemptylineaftersubject]
+=== References
+
+* https://rspec.rubystyle.guide/#empty-line-after-let
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject
+
+[#rspecemptymetadata]
+== RSpec/EmptyMetadata
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 2.24
+| 2.31
+|===
+
+Avoid empty metadata hash.
+
+[#examples-rspecemptymetadata]
+=== Examples
+
+[#enforcedstyle_-symbol-_default_-rspecemptymetadata]
+==== EnforcedStyle: symbol (default)
+
+[source,ruby]
+----
+# bad
+describe 'Something', {}
+
+# good
+describe 'Something'
+----
+
+[#references-rspecemptymetadata]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyMetadata
+
+[#rspecemptyoutput]
+== RSpec/EmptyOutput
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.29
+| -
+|===
+
+Check that the `output` matcher is not called with an empty string.
+
+[#examples-rspecemptyoutput]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect { foo }.to output('').to_stdout
+expect { bar }.not_to output('').to_stderr
+
+# good
+expect { foo }.not_to output.to_stdout
+expect { bar }.to output.to_stderr
+----
+
+[#references-rspecemptyoutput]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyOutput
+
+[#rspeceq]
+== RSpec/Eq
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.24
+| -
+|===
+
+Use `eq` instead of `be ==` to compare objects.
+
+[#examples-rspeceq]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to be == 42
+
+# good
+expect(foo).to eq 42
+----
+
+[#references-rspeceq]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Eq
+
+[#rspecexamplelength]
+== RSpec/ExampleLength
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.5
+| 2.3
+|===
+
+Checks for long examples.
+
+A long example is usually more difficult to understand. Consider
+extracting out some behavior, e.g. with a `let` block, or a helper
+method.
+
+You can set constructs you want to fold with `CountAsOne`.
+Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+Each construct will be counted as one line regardless of
+its actual size.
+
+[#examples-rspecexamplelength]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it do
+  service = described_class.new
+  more_setup
+  more_setup
+  result = service.call
+  expect(result).to be(true)
+end
+
+# good
+it do
+  service = described_class.new
+  result = service.call
+  expect(result).to be(true)
+end
+----
+
+[#countasone_-__array__-_heredoc__-_method_call__-rspecexamplelength]
+==== CountAsOne: ['array', 'heredoc', 'method_call']
+
+[source,ruby]
+----
+it do
+  array = [         # +1
+    1,
+    2
+  ]
+
+  hash = {          # +3
+    key: 'value'
+  }
+
+  msg = <<~HEREDOC  # +1
+    Heredoc
+    content.
+  HEREDOC
+
+  foo(            # +1
+    1,
+    2
+  )
+end               # 6 points
+----
+
+[#configurable-attributes-rspecexamplelength]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Max
+| `5`
+| Integer
+
+| CountAsOne
+| `[]`
+| Array
+|===
+
+[#references-rspecexamplelength]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength
+
+[#rspecexamplewithoutdescription]
+== RSpec/ExampleWithoutDescription
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.22
+| -
+|===
+
+Checks for examples without a description.
+
+RSpec allows for auto-generated example descriptions when there is no
+description provided or the description is an empty one.
+It is acceptable to use `specify` without a description
+
+This cop removes empty descriptions.
+It also defines whether auto-generated description is allowed, based
+on the configured style.
+
+This cop can be configured using the `EnforcedStyle` option
+
+[#examples-rspecexamplewithoutdescription]
+=== Examples
+
+[source,ruby]
+----
+# always good
+specify do
+  result = service.call
+  expect(result).to be(true)
+end
+----
+
+[#_enforcedstyle_-always_allow_-_default_-rspecexamplewithoutdescription]
+==== `EnforcedStyle: always_allow` (default)
+
+[source,ruby]
+----
+# bad
+it('') { is_expected.to be_good }
+specify '' do
+  result = service.call
+  expect(result).to be(true)
+end
+
+# good
+it { is_expected.to be_good }
+specify do
+  result = service.call
+  expect(result).to be(true)
+end
+----
+
+[#_enforcedstyle_-single_line_only_-rspecexamplewithoutdescription]
+==== `EnforcedStyle: single_line_only`
+
+[source,ruby]
+----
+# bad
+it('') { is_expected.to be_good }
+it do
+  result = service.call
+  expect(result).to be(true)
+end
+
+# good
+it { is_expected.to be_good }
+----
+
+[#_enforcedstyle_-disallow_-rspecexamplewithoutdescription]
+==== `EnforcedStyle: disallow`
+
+[source,ruby]
+----
+# bad
+it { is_expected.to be_good }
+it do
+  result = service.call
+  expect(result).to be(true)
+end
+----
+
+[#configurable-attributes-rspecexamplewithoutdescription]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `always_allow`
+| `always_allow`, `single_line_only`, `disallow`
+|===
+
+[#references-rspecexamplewithoutdescription]
+=== References
+
+* https://rspec.rubystyle.guide/#it-and-specify
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription
+
+[#rspecexamplewording]
+== RSpec/ExampleWording
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.0
+| 2.13
+|===
+
+Checks for common mistakes in example descriptions.
+
+This cop will correct docstrings that begin with 'should' and 'it'.
+This cop will also look for insufficient examples and call them out.
+
+The autocorrect is experimental - use with care! It can be configured
+with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
+
+Use the DisallowedExamples setting to prevent unclear or insufficient
+descriptions. Please note that this config will not be treated as
+case sensitive.
+
+[#examples-rspecexamplewording]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it 'should find nothing' do
+end
+
+it 'will find nothing' do
+end
+
+# good
+it 'finds nothing' do
+end
+----
+
+[source,ruby]
+----
+# bad
+it 'it does things' do
+end
+
+# good
+it 'does things' do
+end
+----
+
+[#_disallowedexamples_-__works___-_default_-rspecexamplewording]
+==== `DisallowedExamples: ['works']` (default)
+
+[source,ruby]
+----
+# bad
+it 'works' do
+end
+
+# good
+it 'marks the task as done' do
+end
+----
+
+[#configurable-attributes-rspecexamplewording]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| CustomTransform
+| `{"be" => "is", "BE" => "IS", "have" => "has", "HAVE" => "HAS"}`
+| 
+
+| IgnoredWords
+| `[]`
+| Array
+
+| DisallowedExamples
+| `works`
+| Array
+|===
+
+[#references-rspecexamplewording]
+=== References
+
+* https://rspec.rubystyle.guide/#should-in-example-docstrings
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording
+* http://betterspecs.org/#should
+
+[#rspecexcessivedocstringspacing]
+== RSpec/ExcessiveDocstringSpacing
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.5
+| -
+|===
+
+Checks for excessive whitespace in example descriptions.
+
+[#examples-rspecexcessivedocstringspacing]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it '  has  excessive   spacing  ' do
+end
+
+# good
+it 'has excessive spacing' do
+end
+----
+
+[source,ruby]
+----
+# bad
+context '  when a condition   is met  ' do
+end
+
+# good
+context 'when a condition is met' do
+end
+----
+
+[#references-rspecexcessivedocstringspacing]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExcessiveDocstringSpacing
+
+[#rspecexpectactual]
+== RSpec/ExpectActual
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.7
+| 2.23
+|===
+
+Checks for `expect(...)` calls containing literal values.
+
+Autocorrection is performed when the expected is not a literal.
+
+[#examples-rspecexpectactual]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(5).to eq(price)
+expect(/foo/).to eq(pattern)
+expect("John").to eq(name)
+
+# good
+expect(price).to eq(5)
+expect(pattern).to eq(/foo/)
+expect(name).to eq("John")
+
+# bad (not supported autocorrection)
+expect(false).to eq(true)
+----
+
+[#configurable-attributes-rspecexpectactual]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Exclude
+| `+**/spec/routing/**/*+`
+| Array
+|===
+
+[#references-rspecexpectactual]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual
+
+[#rspecexpectchange]
+== RSpec/ExpectChange
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always (Unsafe)
+| 1.22
+| 2.5
+|===
+
+Checks for consistent style of change matcher.
+
+Enforces either passing a receiver and message as method arguments,
+or a block.
+
+This cop can be configured using the `EnforcedStyle` option.
+
+[#safety-rspecexpectchange]
+=== Safety
+
+Autocorrection is unsafe because `method_call` style calls the
+receiver *once* and sends the message to it before and after
+calling the `expect` block, whereas `block` style calls the
+expression *twice*, including the receiver.
+
+If your receiver is dynamic (e.g., the result of a method call) and
+you expect it to be called before and after the `expect` block,
+changing from `block` to `method_call` style may break your test.
+
+[source,ruby]
+----
+expect { run }.to change { my_method.message }
+# `my_method` is called before and after `run`
+
+expect { run }.to change(my_method, :message)
+# `my_method` is called once, but `message` is called on it twice
+----
+
+[#examples-rspecexpectchange]
+=== Examples
+
+[#_enforcedstyle_-method_call_-_default_-rspecexpectchange]
+==== `EnforcedStyle: method_call` (default)
+
+[source,ruby]
+----
+# bad
+expect { run }.to change { Foo.bar }
+expect { run }.to change { foo.baz }
+
+# good
+expect { run }.to change(Foo, :bar)
+expect { run }.to change(foo, :baz)
+# also good when there are arguments or chained method calls
+expect { run }.to change { Foo.bar(:count) }
+expect { run }.to change { user.reload.name }
+----
+
+[#_enforcedstyle_-block_-rspecexpectchange]
+==== `EnforcedStyle: block`
+
+[source,ruby]
+----
+# bad
+expect { run }.to change(Foo, :bar)
+
+# good
+expect { run }.to change { Foo.bar }
+----
+
+[#configurable-attributes-rspecexpectchange]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `method_call`
+| `method_call`, `block`
+|===
+
+[#references-rspecexpectchange]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange
+
+[#rspecexpectinhook]
+== RSpec/ExpectInHook
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.16
+| -
+|===
+
+Do not use `expect` in hooks such as `before`.
+
+[#examples-rspecexpectinhook]
+=== Examples
+
+[source,ruby]
+----
+# bad
+before do
+  expect(something).to eq 'foo'
+end
+
+# bad
+after do
+  expect_any_instance_of(Something).to receive(:foo)
+end
+
+# good
+it do
+  expect(something).to eq 'foo'
+end
+----
+
+[#references-rspecexpectinhook]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook
+
+[#rspecexpectinlet]
+== RSpec/ExpectInLet
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.30
+| -
+|===
+
+Do not use `expect` in let.
+
+[#examples-rspecexpectinlet]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) do
+  expect(something).to eq 'foo'
+end
+
+# good
+it do
+  expect(something).to eq 'foo'
+end
+----
+
+[#references-rspecexpectinlet]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInLet
+
+[#rspecexpectoutput]
+== RSpec/ExpectOutput
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.10
+| -
+|===
+
+Checks for opportunities to use `expect { ... }.to output`.
+
+[#examples-rspecexpectoutput]
+=== Examples
+
+[source,ruby]
+----
+# bad
+$stdout = StringIO.new
+my_app.print_report
+$stdout = STDOUT
+expect($stdout.string).to eq('Hello World')
+
+# good
+expect { my_app.print_report }.to output('Hello World').to_stdout
+----
+
+[#references-rspecexpectoutput]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput
+
+[#rspecfocus]
+== RSpec/Focus
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.5
+| 2.31
+|===
+
+Checks if examples are focused.
+
+This cop does not support autocorrection in some cases.
+
+[#examples-rspecfocus]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass, focus: true do
+end
+
+describe MyClass, :focus do
+end
+
+fdescribe MyClass do
+end
+
+# good
+describe MyClass do
+end
+
+# bad
+fdescribe 'test' do; end
+
+# good
+describe 'test' do; end
+
+# bad
+shared_examples 'test', focus: true do; end
+
+# good
+shared_examples 'test' do; end
+
+# bad
+shared_context 'test', focus: true do; end
+
+# good
+shared_context 'test' do; end
+
+# bad (does not support autocorrection)
+focus 'test' do; end
+----
+
+[#references-rspecfocus]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus
+
+[#rspechookargument]
+== RSpec/HookArgument
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.7
+| -
+|===
+
+Checks the arguments passed to `before`, `around`, and `after`.
+
+This cop checks for consistent style when specifying RSpec
+hooks which run for each example. There are three supported
+styles: "implicit", "each", and "example." All styles have
+the same behavior.
+
+[#examples-rspechookargument]
+=== Examples
+
+[#_enforcedstyle_-implicit_-_default_-rspechookargument]
+==== `EnforcedStyle: implicit` (default)
+
+[source,ruby]
+----
+# bad
+before(:each) do
+  # ...
+end
+
+# bad
+before(:example) do
+  # ...
+end
+
+# good
+before do
+  # ...
+end
+----
+
+[#_enforcedstyle_-each_-rspechookargument]
+==== `EnforcedStyle: each`
+
+[source,ruby]
+----
+# bad
+before(:example) do
+  # ...
+end
+
+# bad
+before do
+  # ...
+end
+
+# good
+before(:each) do
+  # ...
+end
+----
+
+[#_enforcedstyle_-example_-rspechookargument]
+==== `EnforcedStyle: example`
+
+[source,ruby]
+----
+# bad
+before(:each) do
+  # ...
+end
+
+# bad
+before do
+  # ...
+end
+
+# good
+before(:example) do
+  # ...
+end
+----
+
+[#configurable-attributes-rspechookargument]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `implicit`
+| `implicit`, `each`, `example`
+|===
+
+[#references-rspechookargument]
+=== References
+
+* https://rspec.rubystyle.guide/#redundant-beforeeach
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument
+
+[#rspechooksbeforeexamples]
+== RSpec/HooksBeforeExamples
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.29
+| 2.31
+|===
+
+Checks for before/around/after hooks that come after an example.
+
+[#examples-rspechooksbeforeexamples]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it 'checks what foo does' do
+  expect(foo).to be
+end
+
+before { prepare }
+after { clean_up }
+
+# good
+before { prepare }
+after { clean_up }
+
+it 'checks what foo does' do
+  expect(foo).to be
+end
+----
+
+[#references-rspechooksbeforeexamples]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples
+
+[#rspecidenticalequalityassertion]
+== RSpec/IdenticalEqualityAssertion
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.4
+| -
+|===
+
+Checks for equality assertions with identical expressions on both sides.
+
+[#examples-rspecidenticalequalityassertion]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo.bar).to eq(foo.bar)
+expect(foo.bar).to eql(foo.bar)
+
+# good
+expect(foo.bar).to eq(2)
+expect(foo.bar).to eql(2)
+----
+
+[#references-rspecidenticalequalityassertion]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IdenticalEqualityAssertion
+
+[#rspecimplicitblockexpectation]
+== RSpec/ImplicitBlockExpectation
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.35
+| -
+|===
+
+Check that implicit block expectation syntax is not used.
+
+Prefer using explicit block expectations.
+
+[#examples-rspecimplicitblockexpectation]
+=== Examples
+
+[source,ruby]
+----
+# bad
+subject { -> { do_something } }
+it { is_expected.to change(something).to(new_value) }
+
+# good
+it 'changes something to a new value' do
+  expect { do_something }.to change(something).to(new_value)
+end
+----
+
+[#references-rspecimplicitblockexpectation]
+=== References
+
+* https://rspec.rubystyle.guide/#implicit-block-expectations
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation
+
+[#rspecimplicitexpect]
+== RSpec/ImplicitExpect
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.8
+| -
+|===
+
+Check that a consistent implicit expectation style is used.
+
+This cop can be configured using the `EnforcedStyle` option
+and supports the `--auto-gen-config` flag.
+
+[#examples-rspecimplicitexpect]
+=== Examples
+
+[#_enforcedstyle_-is_expected_-_default_-rspecimplicitexpect]
+==== `EnforcedStyle: is_expected` (default)
+
+[source,ruby]
+----
+# bad
+it { should be_truthy }
+
+# good
+it { is_expected.to be_truthy }
+----
+
+[#_enforcedstyle_-should_-rspecimplicitexpect]
+==== `EnforcedStyle: should`
+
+[source,ruby]
+----
+# bad
+it { is_expected.to be_truthy }
+
+# good
+it { should be_truthy }
+----
+
+[#configurable-attributes-rspecimplicitexpect]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `is_expected`
+| `is_expected`, `should`
+|===
+
+[#references-rspecimplicitexpect]
+=== References
+
+* https://rspec.rubystyle.guide/#use-expect
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect
+
+[#rspecimplicitsubject]
+== RSpec/ImplicitSubject
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.29
+| 2.13
+|===
+
+Checks for usage of implicit subject (`is_expected` / `should`).
+
+This cop can be configured using the `EnforcedStyle` option
+
+[#examples-rspecimplicitsubject]
+=== Examples
+
+[#_enforcedstyle_-single_line_only_-_default_-rspecimplicitsubject]
+==== `EnforcedStyle: single_line_only` (default)
+
+[source,ruby]
+----
+# bad
+it do
+  is_expected.to be_truthy
+end
+
+# good
+it { is_expected.to be_truthy }
+it do
+  expect(subject).to be_truthy
+end
+----
+
+[#_enforcedstyle_-single_statement_only_-rspecimplicitsubject]
+==== `EnforcedStyle: single_statement_only`
+
+[source,ruby]
+----
+# bad
+it do
+  foo = 1
+  is_expected.to be_truthy
+end
+
+# good
+it do
+  foo = 1
+  expect(subject).to be_truthy
+end
+it do
+  is_expected.to be_truthy
+end
+----
+
+[#_enforcedstyle_-disallow_-rspecimplicitsubject]
+==== `EnforcedStyle: disallow`
+
+[source,ruby]
+----
+# bad
+it { is_expected.to be_truthy }
+
+# good
+it { expect(subject).to be_truthy }
+----
+
+[#_enforcedstyle_-require_implicit_-rspecimplicitsubject]
+==== `EnforcedStyle: require_implicit`
+
+[source,ruby]
+----
+# bad
+it { expect(subject).to be_truthy }
+
+# good
+it { is_expected.to be_truthy }
+
+# bad
+it do
+  expect(subject).to be_truthy
+end
+
+# good
+it do
+  is_expected.to be_truthy
+end
+
+# good
+it { expect(named_subject).to be_truthy }
+----
+
+[#configurable-attributes-rspecimplicitsubject]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `single_line_only`
+| `single_line_only`, `single_statement_only`, `disallow`, `require_implicit`
+|===
+
+[#references-rspecimplicitsubject]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject
+
+[#rspecincludeexamples]
+== RSpec/IncludeExamples
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Pending
+| Yes
+| Always (Unsafe)
+| 3.6
+| <<next>>
+|===
+
+Checks for usage of `include_examples`.
+
+`include_examples`, unlike `it_behaves_like`, does not create its
+own context. As such, using `subject`, `let`, `before`/`after`, etc.
+within shared examples included with `include_examples` can have
+unexpected behavior and side effects.
+
+Prefer using `it_behaves_like` instead.
+
+----
+
+[#safety-rspecincludeexamples]
+=== Safety
+
+`include_examples` and `it_behaves_like` have different scoping
+behaviors.
+Changing `include_examples` to `it_behaves_like` creates a new
+context, altering setup dependencies, which can lead to unexpected
+test failures.
+Specifically, the scope of hooks (`before`, `after`, `around`)
+changes, which may prevent expected setup from being inherited
+correctly.
+
+Additionally, `let` and `subject` are affected by scoping rules.
+When `include_examples` is used, `let` and `subject` defined within
+`shared_examples` are evaluated in the caller's context, allowing
+access to their values.
+In contrast, `it_behaves_like` creates a new context, preventing
+access to `let` or `subject` values from the caller's context.
+
+[source,ruby]
+----
+shared_examples "mock behavior" do
+  before do
+    allow(service).to receive(:call).and_return("mocked response")
+  end
+
+  it "returns mocked response" do
+    expect(service.call).to eq "mocked response"
+  end
+end
+
+context "working example with include_examples" do
+  let(:service) { double(:service) }
+
+  include_examples "mock behavior"
+
+  it "uses the mocked service" do
+    expect(service.call).to eq "mocked response" # Passes
+  end
+end
+
+context "broken example with it_behaves_like" do
+  let(:service) { double(:service) }
+
+  it_behaves_like "mock behavior"
+
+  it "unexpectedly does not use the mocked service" do
+    # Fails because `it_behaves_like` does not apply the mock setup
+    expect(service.call).to eq "mocked response"
+  end
+end
+
+[#examples-rspecincludeexamples]
+=== Examples
+
+[source,ruby]
+----
+# bad
+include_examples 'examples'
+
+# good
+it_behaves_like 'examples'
+----
+
+[#references-rspecincludeexamples]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IncludeExamples
+
+[#rspecindexedlet]
+== RSpec/IndexedLet
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.20
+| 2.23
+|===
+
+Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+
+It makes reading the test harder because it's not clear what exactly
+is tested by this particular example.
+
+The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+will also read those set in `Naming/VariableNumber`.
+
+[#examples-rspecindexedlet]
+=== Examples
+
+[#_max_-1-_default__-rspecindexedlet]
+==== `Max: 1 (default)`
+
+[source,ruby]
+----
+# bad
+let(:item_1) { create(:item) }
+let(:item_2) { create(:item) }
+
+let(:item1) { create(:item) }
+let(:item2) { create(:item) }
+
+# good
+
+let(:visible_item) { create(:item, visible: true) }
+let(:invisible_item) { create(:item, visible: false) }
+----
+
+[#_max_-2_-rspecindexedlet]
+==== `Max: 2`
+
+[source,ruby]
+----
+# bad
+let(:item_1) { create(:item) }
+let(:item_2) { create(:item) }
+let(:item_3) { create(:item) }
+
+# good
+let(:item_1) { create(:item) }
+let(:item_2) { create(:item) }
+----
+
+[#_allowedidentifiers_-__item_1__-_item_2___-rspecindexedlet]
+==== `AllowedIdentifiers: ['item_1', 'item_2']`
+
+[source,ruby]
+----
+# good
+let(:item_1) { create(:item) }
+let(:item_2) { create(:item) }
+----
+
+[#_allowedpatterns_-__item___-rspecindexedlet]
+==== `AllowedPatterns: ['item']`
+
+[source,ruby]
+----
+# good
+let(:item_1) { create(:item) }
+let(:item_2) { create(:item) }
+----
+
+[#configurable-attributes-rspecindexedlet]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Max
+| `1`
+| Integer
+
+| AllowedIdentifiers
+| `[]`
+| Array
+
+| AllowedPatterns
+| `[]`
+| Array
+|===
+
+[#references-rspecindexedlet]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IndexedLet
+
+[#rspecinstancespy]
+== RSpec/InstanceSpy
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.12
+| -
+|===
+
+Checks for `instance_double` used with `have_received`.
+
+[#examples-rspecinstancespy]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it do
+  foo = instance_double(Foo).as_null_object
+  expect(foo).to have_received(:bar)
+end
+
+# good
+it do
+  foo = instance_spy(Foo)
+  expect(foo).to have_received(:bar)
+end
+----
+
+[#references-rspecinstancespy]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy
+
+[#rspecinstancevariable]
+== RSpec/InstanceVariable
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.0
+| 1.7
+|===
+
+Checks for instance variable usage in specs.
+
+This cop can be configured with the option `AssignmentOnly` which
+will configure the cop to only register offenses on instance
+variable usage if the instance variable is also assigned within
+the spec
+
+[#examples-rspecinstancevariable]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  before { @foo = [] }
+  it { expect(@foo).to be_empty }
+end
+
+# good
+describe MyClass do
+  let(:foo) { [] }
+  it { expect(foo).to be_empty }
+end
+----
+
+[#with-assignmentonly-configuration-rspecinstancevariable]
+==== with AssignmentOnly configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/InstanceVariable:
+#   AssignmentOnly: true
+
+# bad
+describe MyClass do
+  before { @foo = [] }
+  it { expect(@foo).to be_empty }
+end
+
+# allowed
+describe MyClass do
+  it { expect(@foo).to be_empty }
+end
+
+# good
+describe MyClass do
+  let(:foo) { [] }
+  it { expect(foo).to be_empty }
+end
+----
+
+[#configurable-attributes-rspecinstancevariable]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| AssignmentOnly
+| `false`
+| Boolean
+|===
+
+[#references-rspecinstancevariable]
+=== References
+
+* https://rspec.rubystyle.guide/#instance-variables
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable
+
+[#rspecisexpectedspecify]
+== RSpec/IsExpectedSpecify
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.27
+| -
+|===
+
+Check for `specify` with `is_expected` and one-liner expectations.
+
+[#examples-rspecisexpectedspecify]
+=== Examples
+
+[source,ruby]
+----
+# bad
+specify { is_expected.to be_truthy }
+
+# good
+it { is_expected.to be_truthy }
+
+# good
+specify do
+  # ...
+end
+specify { expect(sqrt(4)).to eq(2) }
+----
+
+[#references-rspecisexpectedspecify]
+=== References
+
+* https://rspec.rubystyle.guide/#it-and-specify
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IsExpectedSpecify
+
+[#rspecitbehaveslike]
+== RSpec/ItBehavesLike
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.13
+| -
+|===
+
+Checks that only one `it_behaves_like` style is used.
+
+[#examples-rspecitbehaveslike]
+=== Examples
+
+[#_enforcedstyle_-it_behaves_like_-_default_-rspecitbehaveslike]
+==== `EnforcedStyle: it_behaves_like` (default)
+
+[source,ruby]
+----
+# bad
+it_should_behave_like 'a foo'
+
+# good
+it_behaves_like 'a foo'
+----
+
+[#_enforcedstyle_-it_should_behave_like_-rspecitbehaveslike]
+==== `EnforcedStyle: it_should_behave_like`
+
+[source,ruby]
+----
+# bad
+it_behaves_like 'a foo'
+
+# good
+it_should_behave_like 'a foo'
+----
+
+[#configurable-attributes-rspecitbehaveslike]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `it_behaves_like`
+| `it_behaves_like`, `it_should_behave_like`
+|===
+
+[#references-rspecitbehaveslike]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike
+
+[#rspeciteratedexpectation]
+== RSpec/IteratedExpectation
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.14
+| -
+|===
+
+Check that `all` matcher is used instead of iterating over an array.
+
+[#examples-rspeciteratedexpectation]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it 'validates users' do
+  [user1, user2, user3].each { |user| expect(user).to be_valid }
+end
+
+# good
+it 'validates users' do
+  expect([user1, user2, user3]).to all(be_valid)
+end
+----
+
+[#references-rspeciteratedexpectation]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation
+
+[#rspecleadingsubject]
+== RSpec/LeadingSubject
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.7
+| 1.14
+|===
+
+Enforce that subject is the first definition in the test.
+
+[#examples-rspecleadingsubject]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:params) { blah }
+subject { described_class.new(params) }
+
+before { do_something }
+subject { described_class.new(params) }
+
+it { expect_something }
+subject { described_class.new(params) }
+it { expect_something_else }
+
+# good
+subject { described_class.new(params) }
+let(:params) { blah }
+
+# good
+subject { described_class.new(params) }
+before { do_something }
+
+# good
+subject { described_class.new(params) }
+it { expect_something }
+it { expect_something_else }
+----
+
+[#references-rspecleadingsubject]
+=== References
+
+* https://rspec.rubystyle.guide/#leading-subject
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject
+
+[#rspecleakyconstantdeclaration]
+== RSpec/LeakyConstantDeclaration
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.35
+| -
+|===
+
+Checks that no class, module, or constant is declared.
+
+Constants, including classes and modules, when declared in a block
+scope, are defined in global namespace, and leak between examples.
+
+If several examples may define a `DummyClass`, instead of being a
+blank slate class as it will be in the first example, subsequent
+examples will be reopening it and modifying its behavior in
+unpredictable ways.
+Even worse when a class that exists in the codebase is reopened.
+
+Anonymous classes are fine, since they don't result in global
+namespace name clashes.
+
+[#examples-rspecleakyconstantdeclaration]
+=== Examples
+
+[#constants-leak-between-examples-rspecleakyconstantdeclaration]
+==== Constants leak between examples
+
+[source,ruby]
+----
+# bad
+describe SomeClass do
+  OtherClass = Struct.new
+  CONSTANT_HERE = 'I leak into global namespace'
+end
+
+# good
+describe SomeClass do
+  before do
+    stub_const('OtherClass', Struct.new)
+    stub_const('CONSTANT_HERE', 'I only exist during this example')
+  end
+end
+----
+
+[source,ruby]
+----
+# bad
+describe SomeClass do
+  class FooClass < described_class
+    def double_that
+      some_base_method * 2
+    end
+  end
+
+  it { expect(FooClass.new.double_that).to eq(4) }
+end
+
+# good - anonymous class, no constant needs to be defined
+describe SomeClass do
+  let(:foo_class) do
+    Class.new(described_class) do
+      def double_that
+        some_base_method * 2
+      end
+    end
+  end
+
+  it { expect(foo_class.new.double_that).to eq(4) }
+end
+
+# good - constant is stubbed
+describe SomeClass do
+  before do
+    foo_class = Class.new(described_class) do
+                  def do_something
+                  end
+                end
+    stub_const('FooClass', foo_class)
+  end
+
+  it { expect(FooClass.new.double_that).to eq(4) }
+end
+----
+
+[source,ruby]
+----
+# bad
+describe SomeClass do
+  module SomeModule
+    class SomeClass
+      def do_something
+      end
+    end
+  end
+end
+
+# good
+describe SomeClass do
+  before do
+    foo_class = Class.new(described_class) do
+                  def do_something
+                  end
+                end
+    stub_const('SomeModule::SomeClass', foo_class)
+  end
+end
+----
+
+[#references-rspecleakyconstantdeclaration]
+=== References
+
+* https://rspec.rubystyle.guide/#declare-constants
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration
+* https://rspec.info/features/3-12/rspec-mocks/mutating-constants
+
+[#rspecletbeforeexamples]
+== RSpec/LetBeforeExamples
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.16
+| 2.31
+|===
+
+Checks for `let` definitions that come after an example.
+
+[#examples-rspecletbeforeexamples]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) { bar }
+
+it 'checks what foo does' do
+  expect(foo).to be
+end
+
+let(:some) { other }
+
+it 'checks what some does' do
+  expect(some).to be
+end
+
+# good
+let(:foo) { bar }
+let(:some) { other }
+
+it 'checks what foo does' do
+  expect(foo).to be
+end
+
+it 'checks what some does' do
+  expect(some).to be
+end
+----
+
+[#references-rspecletbeforeexamples]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples
+
+[#rspecletsetup]
+== RSpec/LetSetup
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.7
+| -
+|===
+
+Checks unreferenced `let!` calls being used for test setup.
+
+[#examples-rspecletsetup]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let!(:my_widget) { create(:widget) }
+
+it 'counts widgets' do
+  expect(Widget.count).to eq(1)
+end
+
+# good
+it 'counts widgets' do
+  create(:widget)
+  expect(Widget.count).to eq(1)
+end
+
+# good
+before { create(:widget) }
+
+it 'counts widgets' do
+  expect(Widget.count).to eq(1)
+end
+----
+
+[#references-rspecletsetup]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup
+
+[#rspecmatcharray]
+== RSpec/MatchArray
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.19
+| -
+|===
+
+Checks where `match_array` is used.
+
+This cop checks for the following:
+
+- Prefer `contain_exactly` when matching an array with values.
+- Prefer `eq` when using `match_array` with an empty array literal.
+
+[#examples-rspecmatcharray]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it { is_expected.to match_array([content1, content2]) }
+
+# good
+it { is_expected.to contain_exactly(content1, content2) }
+
+# good
+it { is_expected.to match_array([content] + array) }
+
+# good
+it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+----
+
+[#references-rspecmatcharray]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MatchArray
+
+[#rspecmessagechain]
+== RSpec/MessageChain
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.7
+| -
+|===
+
+Check that chains of messages are not being stubbed.
+
+[#examples-rspecmessagechain]
+=== Examples
+
+[source,ruby]
+----
+# bad
+allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
+
+# good
+thing = Thing.new(baz: 42)
+allow(foo).to receive(:bar).and_return(thing)
+----
+
+[#references-rspecmessagechain]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain
+
+[#rspecmessageexpectation]
+== RSpec/MessageExpectation
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| No
+| 1.7
+| 1.8
+|===
+
+Checks for consistent message expectation style.
+
+This cop can be configured in your configuration using the
+`EnforcedStyle` option and supports `--auto-gen-config`.
+
+[#examples-rspecmessageexpectation]
+=== Examples
+
+[#_enforcedstyle_-allow_-_default_-rspecmessageexpectation]
+==== `EnforcedStyle: allow` (default)
+
+[source,ruby]
+----
+# bad
+expect(foo).to receive(:bar)
+
+# good
+allow(foo).to receive(:bar)
+----
+
+[#_enforcedstyle_-expect_-rspecmessageexpectation]
+==== `EnforcedStyle: expect`
+
+[source,ruby]
+----
+# bad
+allow(foo).to receive(:bar)
+
+# good
+expect(foo).to receive(:bar)
+----
+
+[#configurable-attributes-rspecmessageexpectation]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `allow`
+| `allow`, `expect`
+|===
+
+[#references-rspecmessageexpectation]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation
+
+[#rspecmessagespies]
+== RSpec/MessageSpies
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.9
+| -
+|===
+
+Checks that message expectations are set using spies.
+
+This cop can be configured in your configuration using the
+`EnforcedStyle` option and supports `--auto-gen-config`.
+
+[#examples-rspecmessagespies]
+=== Examples
+
+[#_enforcedstyle_-have_received_-_default_-rspecmessagespies]
+==== `EnforcedStyle: have_received` (default)
+
+[source,ruby]
+----
+# bad
+expect(foo).to receive(:bar)
+do_something
+
+# good
+allow(foo).to receive(:bar) # or use instance_spy
+do_something
+expect(foo).to have_received(:bar)
+----
+
+[#_enforcedstyle_-receive_-rspecmessagespies]
+==== `EnforcedStyle: receive`
+
+[source,ruby]
+----
+# bad
+allow(foo).to receive(:bar)
+do_something
+expect(foo).to have_received(:bar)
+
+# good
+expect(foo).to receive(:bar)
+do_something
+----
+
+[#configurable-attributes-rspecmessagespies]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `have_received`
+| `have_received`, `receive`
+|===
+
+[#references-rspecmessagespies]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies
+
+[#rspecmetadatastyle]
+== RSpec/MetadataStyle
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.24
+| -
+|===
+
+Use consistent metadata style.
+
+This cop does not support autocorrection in the case of
+`EnforcedStyle: hash` where the trailing metadata type is ambiguous.
+(e.g. `describe 'Something', :a, b`)
+
+[#examples-rspecmetadatastyle]
+=== Examples
+
+[#enforcedstyle_-symbol-_default_-rspecmetadatastyle]
+==== EnforcedStyle: symbol (default)
+
+[source,ruby]
+----
+# bad
+describe 'Something', a: true
+
+# good
+describe 'Something', :a
+----
+
+[#enforcedstyle_-hash-rspecmetadatastyle]
+==== EnforcedStyle: hash
+
+[source,ruby]
+----
+# bad
+describe 'Something', :a
+
+# good
+describe 'Something', a: true
+----
+
+[#configurable-attributes-rspecmetadatastyle]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `symbol`
+| `hash`, `symbol`
+|===
+
+[#references-rspecmetadatastyle]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MetadataStyle
+
+[#rspecmissingexamplegroupargument]
+== RSpec/MissingExampleGroupArgument
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.28
+| -
+|===
+
+Checks that the first argument to an example group is not empty.
+
+[#examples-rspecmissingexamplegroupargument]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe do
+end
+
+RSpec.describe do
+end
+
+# good
+describe TestedClass do
+end
+
+describe "A feature example" do
+end
+----
+
+[#references-rspecmissingexamplegroupargument]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument
+
+[#rspecmissingexpectationtargetmethod]
+== RSpec/MissingExpectationTargetMethod
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 3.0
+| -
+|===
+
+Checks if `.to`, `not_to` or `to_not` are used.
+
+The RSpec::Expectations::ExpectationTarget must use `to`, `not_to` or
+`to_not` to run. Therefore, this cop checks if other methods are used.
+
+[#examples-rspecmissingexpectationtargetmethod]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(something).kind_of? Foo
+is_expected == 42
+expect{something}.eq? BarError
+
+# good
+expect(something).to be_a Foo
+is_expected.to eq 42
+expect{something}.to raise_error BarError
+----
+
+[#references-rspecmissingexpectationtargetmethod]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExpectationTargetMethod
+
+[#rspecmultipledescribes]
+== RSpec/MultipleDescribes
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.0
+| -
+|===
+
+Checks for multiple top-level example groups.
+
+Multiple descriptions for the same class or module should either
+be nested or separated into different test files.
+
+[#examples-rspecmultipledescribes]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass, '.do_something' do
+end
+describe MyClass, '.do_something_else' do
+end
+
+# good
+describe MyClass do
+  describe '.do_something' do
+  end
+  describe '.do_something_else' do
+  end
+end
+----
+
+[#references-rspecmultipledescribes]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes
+
+[#rspecmultipleexpectations]
+== RSpec/MultipleExpectations
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.7
+| 1.21
+|===
+
+Checks if examples contain too many `expect` calls.
+
+This cop is configurable using the `Max` option
+and works with `--auto-gen-config`.
+
+[#examples-rspecmultipleexpectations]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe UserCreator do
+  it 'builds a user' do
+    expect(user.name).to eq("John")
+    expect(user.age).to eq(22)
+  end
+end
+
+# good
+describe UserCreator do
+  it 'sets the users name' do
+    expect(user.name).to eq("John")
+  end
+
+  it 'sets the users age' do
+    expect(user.age).to eq(22)
+  end
+end
+----
+
+[#_aggregate_failures_-true_-_default_-rspecmultipleexpectations]
+==== `aggregate_failures: true` (default)
+
+[source,ruby]
+----
+# good - the cop ignores when RSpec aggregates failures
+describe UserCreator do
+  it 'builds a user', :aggregate_failures do
+    expect(user.name).to eq("John")
+    expect(user.age).to eq(22)
+  end
+end
+----
+
+[#_aggregate_failures_-false_-rspecmultipleexpectations]
+==== `aggregate_failures: false`
+
+[source,ruby]
+----
+# Detected as an offense
+describe UserCreator do
+  it 'builds a user', aggregate_failures: false do
+    expect(user.name).to eq("John")
+    expect(user.age).to eq(22)
+  end
+end
+----
+
+[#_max_-1_-_default_-rspecmultipleexpectations]
+==== `Max: 1` (default)
+
+[source,ruby]
+----
+# bad
+describe UserCreator do
+  it 'builds a user' do
+    expect(user.name).to eq("John")
+    expect(user.age).to eq(22)
+  end
+end
+----
+
+[#_max_-2_-rspecmultipleexpectations]
+==== `Max: 2`
+
+[source,ruby]
+----
+# good
+describe UserCreator do
+  it 'builds a user' do
+    expect(user.name).to eq("John")
+    expect(user.age).to eq(22)
+  end
+end
+----
+
+[#configurable-attributes-rspecmultipleexpectations]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Max
+| `1`
+| Integer
+|===
+
+[#references-rspecmultipleexpectations]
+=== References
+
+* https://rspec.rubystyle.guide/#expectation-per-example
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations
+* http://betterspecs.org/#single
+
+[#rspecmultiplememoizedhelpers]
+== RSpec/MultipleMemoizedHelpers
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.43
+| -
+|===
+
+Checks if example groups contain too many `let` and `subject` calls.
+
+This cop is configurable using the `Max` option and the `AllowSubject`
+which will configure the cop to only register offenses on calls to
+`let` and not calls to `subject`.
+
+[#examples-rspecmultiplememoizedhelpers]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  let(:foo) { [] }
+  let(:bar) { [] }
+  let!(:baz) { [] }
+  let(:qux) { [] }
+  let(:quux) { [] }
+  let(:quuz) { {} }
+end
+
+describe MyClass do
+  let(:foo) { [] }
+  let(:bar) { [] }
+  let!(:baz) { [] }
+
+  context 'when stuff' do
+    let(:qux) { [] }
+    let(:quux) { [] }
+    let(:quuz) { {} }
+  end
+end
+
+# good
+describe MyClass do
+  let(:bar) { [] }
+  let!(:baz) { [] }
+  let(:qux) { [] }
+  let(:quux) { [] }
+  let(:quuz) { {} }
+end
+
+describe MyClass do
+  context 'when stuff' do
+    let(:foo) { [] }
+    let(:bar) { [] }
+    let!(:booger) { [] }
+  end
+
+  context 'when other stuff' do
+    let(:qux) { [] }
+    let(:quux) { [] }
+    let(:quuz) { {} }
+  end
+end
+----
+
+[#when-disabling-allowsubject-configuration-rspecmultiplememoizedhelpers]
+==== when disabling AllowSubject configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/MultipleMemoizedHelpers:
+#   AllowSubject: false
+
+# bad - `subject` counts towards memoized helpers
+describe MyClass do
+  subject { {} }
+  let(:foo) { [] }
+  let(:bar) { [] }
+  let!(:baz) { [] }
+  let(:qux) { [] }
+  let(:quux) { [] }
+end
+----
+
+[#with-max-configuration-rspecmultiplememoizedhelpers]
+==== with Max configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/MultipleMemoizedHelpers:
+#   Max: 1
+
+# bad
+describe MyClass do
+  let(:foo) { [] }
+  let(:bar) { [] }
+end
+----
+
+[#configurable-attributes-rspecmultiplememoizedhelpers]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| AllowSubject
+| `true`
+| Boolean
+
+| Max
+| `5`
+| Integer
+|===
+
+[#references-rspecmultiplememoizedhelpers]
+=== References
+
+* https://rspec.rubystyle.guide/#let-blocks
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleMemoizedHelpers
+
+[#rspecmultiplesubjects]
+== RSpec/MultipleSubjects
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.16
+| -
+|===
+
+Checks if an example group defines `subject` multiple times.
+
+This cop does not support autocorrection in some cases.
+The autocorrect behavior for this cop depends on the type of
+duplication:
+
+  - If multiple named subjects are defined then this probably indicates
+    that the overwritten subjects (all subjects except the last
+    definition) are effectively being used to define helpers. In this
+    case they are replaced with `let`.
+
+  - If multiple unnamed subjects are defined though then this can *only*
+    be dead code and we remove the overwritten subject definitions.
+
+  - If subjects are defined with `subject!` then we don't autocorrect.
+    This is enough of an edge case that people can just move this to
+    a `before` hook on their own
+
+[#examples-rspecmultiplesubjects]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe Foo do
+  subject(:user) { User.new }
+  subject(:post) { Post.new }
+end
+
+# good
+describe Foo do
+  let(:user) { User.new }
+  subject(:post) { Post.new }
+end
+
+# bad (does not support autocorrection)
+describe Foo do
+  subject!(:user) { User.new }
+  subject!(:post) { Post.new }
+end
+
+# good
+describe Foo do
+  before do
+    User.new
+    Post.new
+  end
+end
+----
+
+[#references-rspecmultiplesubjects]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects
+
+[#rspecnamedsubject]
+== RSpec/NamedSubject
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.5.3
+| 2.15
+|===
+
+Checks for explicitly referenced test subjects.
+
+RSpec lets you declare an "implicit subject" using `subject { ... }`
+which allows for tests like `it { is_expected.to be_valid }`.
+If you need to reference your test subject you should explicitly
+name it using `subject(:your_subject_name) { ... }`. Your test subjects
+should be the most important object in your tests so they deserve
+a descriptive name.
+
+This cop can be configured in your configuration using `EnforcedStyle`,
+and `IgnoreSharedExamples` which will not report offenses for implicit
+subjects in shared example groups.
+
+[#examples-rspecnamedsubject]
+=== Examples
+
+[#_enforcedstyle_-always_-_default_-rspecnamedsubject]
+==== `EnforcedStyle: always` (default)
+
+[source,ruby]
+----
+# bad
+RSpec.describe User do
+  subject { described_class.new }
+
+  it 'is valid' do
+    expect(subject.valid?).to be(true)
+  end
+end
+
+# good
+RSpec.describe User do
+  subject(:user) { described_class.new }
+
+  it 'is valid' do
+    expect(user.valid?).to be(true)
+  end
+end
+
+# also good
+RSpec.describe User do
+  subject(:user) { described_class.new }
+
+  it { is_expected.to be_valid }
+end
+----
+
+[#_enforcedstyle_-named_only_-rspecnamedsubject]
+==== `EnforcedStyle: named_only`
+
+[source,ruby]
+----
+# bad
+RSpec.describe User do
+  subject(:user) { described_class.new }
+
+  it 'is valid' do
+    expect(subject.valid?).to be(true)
+  end
+end
+
+# good
+RSpec.describe User do
+  subject(:user) { described_class.new }
+
+  it 'is valid' do
+    expect(user.valid?).to be(true)
+  end
+end
+
+# also good
+RSpec.describe User do
+  subject { described_class.new }
+
+  it { is_expected.to be_valid }
+end
+
+# acceptable
+RSpec.describe User do
+  subject { described_class.new }
+
+  it 'is valid' do
+    expect(subject.valid?).to be(true)
+  end
+end
+----
+
+[#configurable-attributes-rspecnamedsubject]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `always`
+| `always`, `named_only`
+
+| IgnoreSharedExamples
+| `true`
+| Boolean
+|===
+
+[#references-rspecnamedsubject]
+=== References
+
+* https://rspec.rubystyle.guide/#use-subject
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject
+
+[#rspecnestedgroups]
+== RSpec/NestedGroups
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.7
+| 2.13
+|===
+
+Checks for nested example groups.
+
+This cop is configurable using the `Max` option
+and supports `--auto-gen-config`.
+
+[#examples-rspecnestedgroups]
+=== Examples
+
+[source,ruby]
+----
+# bad
+context 'when using some feature' do
+  let(:some)    { :various }
+  let(:feature) { :setup   }
+
+  context 'when user is signed in' do  # flagged by rubocop
+    let(:user) do
+      UserCreate.call(user_attributes)
+    end
+
+    let(:user_attributes) do
+      {
+        name: 'John',
+        age:  22,
+        role: role
+      }
+    end
+
+    context 'when user is an admin' do # flagged by rubocop
+      let(:role) { 'admin' }
+
+      it 'blah blah'
+      it 'yada yada'
+    end
+  end
+end
+
+# good
+context 'using some feature as an admin' do
+  let(:some)    { :various }
+  let(:feature) { :setup   }
+
+  let(:user) do
+    UserCreate.call(
+      name: 'John',
+      age:  22,
+      role: 'admin'
+    )
+  end
+
+  it 'blah blah'
+  it 'yada yada'
+end
+----
+
+[#_max_-3_-_default_-rspecnestedgroups]
+==== `Max: 3` (default)
+
+[source,ruby]
+----
+# bad
+describe Foo do
+  context 'foo' do
+    context 'bar' do
+      context 'baz' do # flagged by rubocop
+      end
+    end
+  end
+end
+----
+
+[#_max_-2_-rspecnestedgroups]
+==== `Max: 2`
+
+[source,ruby]
+----
+# bad
+describe Foo do
+  context 'foo' do
+    context 'bar' do # flagged by rubocop
+      context 'baz' do # flagged by rubocop
+      end
+    end
+  end
+end
+----
+
+[#_allowedgroups_-__-_default__-rspecnestedgroups]
+==== `AllowedGroups: [] (default)`
+
+[source,ruby]
+----
+describe Foo do # <-- nested groups 1
+  context 'foo' do # <-- nested groups 2
+    context 'bar' do # <-- nested groups 3
+    end
+  end
+end
+----
+
+[#_allowedgroups_-_path__-rspecnestedgroups]
+==== `AllowedGroups: [path]`
+
+[source,ruby]
+----
+describe Foo do # <-- nested groups 1
+  path '/foo' do # <-- nested groups 1 (not counted)
+    context 'bar' do # <-- nested groups 2
+    end
+  end
+end
+----
+
+[#configurable-attributes-rspecnestedgroups]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Max
+| `3`
+| Integer
+
+| AllowedGroups
+| `[]`
+| Array
+|===
+
+[#references-rspecnestedgroups]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups
+
+[#rspecnoexpectationexample]
+== RSpec/NoExpectationExample
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| No
+| No
+| 2.13
+| 2.14
+|===
+
+Checks if an example contains any expectation.
+
+All RSpec's example and expectation methods are covered by default.
+If you are using your own custom methods,
+add the following configuration:
+
+  RSpec:
+    Language:
+      Examples:
+        Regular:
+          - custom_it
+      Expectations:
+        - custom_expect
+
+This cop can be customized with an allowed expectation methods pattern
+with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed
+by default.
+
+[#examples-rspecnoexpectationexample]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it do
+  a?
+end
+
+# good
+it do
+  expect(a?).to be(true)
+end
+----
+
+[#_allowedpatterns_-configuration-rspecnoexpectationexample]
+==== `AllowedPatterns` configuration
+
+[source,ruby]
+----
+# .rubocop.yml
+# RSpec/NoExpectationExample:
+#   AllowedPatterns:
+#     - ^expect_
+#     - ^assert_
+----
+
+[source,ruby]
+----
+# bad
+it do
+  not_expect_something
+end
+
+# good
+it do
+  expect_something
+end
+
+it do
+  assert_something
+end
+----
+
+[#configurable-attributes-rspecnoexpectationexample]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| AllowedPatterns
+| `^expect_`, `^assert_`
+| Array
+|===
+
+[#references-rspecnoexpectationexample]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NoExpectationExample
+
+[#rspecnottonot]
+== RSpec/NotToNot
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.4
+| -
+|===
+
+Checks for consistent method usage for negating expectations.
+
+[#examples-rspecnottonot]
+=== Examples
+
+[#_enforcedstyle_-not_to_-_default_-rspecnottonot]
+==== `EnforcedStyle: not_to` (default)
+
+[source,ruby]
+----
+# bad
+it '...' do
+  expect(false).to_not be_true
+end
+
+# good
+it '...' do
+  expect(false).not_to be_true
+end
+----
+
+[#_enforcedstyle_-to_not_-rspecnottonot]
+==== `EnforcedStyle: to_not`
+
+[source,ruby]
+----
+# bad
+it '...' do
+  expect(false).not_to be_true
+end
+
+# good
+it '...' do
+  expect(false).to_not be_true
+end
+----
+
+[#configurable-attributes-rspecnottonot]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `not_to`
+| `not_to`, `to_not`
+|===
+
+[#references-rspecnottonot]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot
+
+[#rspecoverwritingsetup]
+== RSpec/OverwritingSetup
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.14
+| -
+|===
+
+Checks if there is a let/subject that overwrites an existing one.
+
+[#examples-rspecoverwritingsetup]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) { bar }
+let(:foo) { baz }
+
+subject(:foo) { bar }
+let(:foo) { baz }
+
+let(:foo) { bar }
+let!(:foo) { baz }
+
+# good
+subject(:test) { something }
+let(:foo) { bar }
+let(:baz) { baz }
+let!(:other) { other }
+----
+
+[#references-rspecoverwritingsetup]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup
+
+[#rspecpending]
+== RSpec/Pending
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Disabled
+| Yes
+| No
+| 1.25
+| -
+|===
+
+Checks for any pending or skipped examples.
+
+[#examples-rspecpending]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe MyClass do
+  it "should be true"
+end
+
+describe MyClass do
+  it "should be true", skip: true do
+    expect(1).to eq(2)
+  end
+end
+
+describe MyClass do
+  it "should be true" do
+    pending
+  end
+end
+
+describe MyClass do
+  xit "should be true" do
+  end
+end
+
+# good
+describe MyClass do
+end
+----
+
+[#references-rspecpending]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending
+
+[#rspecpendingwithoutreason]
+== RSpec/PendingWithoutReason
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.16
+| -
+|===
+
+Checks for pending or skipped examples without reason.
+
+[#examples-rspecpendingwithoutreason]
+=== Examples
+
+[source,ruby]
+----
+# bad
+pending 'does something' do
+end
+
+# bad
+it 'does something', :pending do
+end
+
+# bad
+it 'does something' do
+  pending
+end
+
+# bad
+xdescribe 'something' do
+end
+
+# bad
+skip 'does something' do
+end
+
+# bad
+it 'does something', :skip do
+end
+
+# bad
+it 'does something' do
+  skip
+end
+
+# bad
+it 'does something'
+
+# good
+it 'does something' do
+  pending 'reason'
+end
+
+# good
+it 'does something' do
+  skip 'reason'
+end
+
+# good
+it 'does something', pending: 'reason' do
+end
+
+# good
+it 'does something', skip: 'reason' do
+end
+----
+
+[#references-rspecpendingwithoutreason]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PendingWithoutReason
+
+[#rspecpredicatematcher]
+== RSpec/PredicateMatcher
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always (Unsafe)
+| 1.16
+| -
+|===
+
+Prefer using predicate matcher over using predicate method directly.
+
+RSpec defines magic matchers for predicate methods.
+This cop recommends to use the predicate matcher instead of using
+predicate method directly.
+
+[#examples-rspecpredicatematcher]
+=== Examples
+
+[#strict_-true_-enforcedstyle_-inflected-_default_-rspecpredicatematcher]
+==== Strict: true, EnforcedStyle: inflected (default)
+
+[source,ruby]
+----
+# bad
+expect(foo.something?).to be_truthy
+
+# good
+expect(foo).to be_something
+
+# also good - It checks "true" strictly.
+expect(foo.something?).to be(true)
+----
+
+[#strict_-false_-enforcedstyle_-inflected-rspecpredicatematcher]
+==== Strict: false, EnforcedStyle: inflected
+
+[source,ruby]
+----
+# bad
+expect(foo.something?).to be_truthy
+expect(foo.something?).to be(true)
+
+# good
+expect(foo).to be_something
+----
+
+[#strict_-true_-enforcedstyle_-explicit-rspecpredicatematcher]
+==== Strict: true, EnforcedStyle: explicit
+
+[source,ruby]
+----
+# bad
+expect(foo).to be_something
+
+# good - the above code is rewritten to it by this cop
+expect(foo.something?).to be(true)
+
+# bad - no autocorrect
+expect(foo)
+  .to be_something(<<~TEXT)
+    bar
+  TEXT
+
+# good
+expect(foo.something?(<<~TEXT)).to be(true)
+  bar
+TEXT
+----
+
+[#strict_-false_-enforcedstyle_-explicit-rspecpredicatematcher]
+==== Strict: false, EnforcedStyle: explicit
+
+[source,ruby]
+----
+# bad
+expect(foo).to be_something
+
+# good - the above code is rewritten to it by this cop
+expect(foo.something?).to be_truthy
+----
+
+[#configurable-attributes-rspecpredicatematcher]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Strict
+| `true`
+| Boolean
+
+| EnforcedStyle
+| `inflected`
+| `inflected`, `explicit`
+
+| AllowedExplicitMatchers
+| `[]`
+| Array
+|===
+
+[#references-rspecpredicatematcher]
+=== References
+
+* https://rspec.rubystyle.guide/#predicate-matchers
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher
+
+[#rspecreceivecounts]
+== RSpec/ReceiveCounts
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.26
+| -
+|===
+
+Check for `once` and `twice` receive counts matchers usage.
+
+[#examples-rspecreceivecounts]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to receive(:bar).exactly(1).times
+expect(foo).to receive(:bar).exactly(2).times
+expect(foo).to receive(:bar).at_least(1).times
+expect(foo).to receive(:bar).at_least(2).times
+expect(foo).to receive(:bar).at_most(1).times
+expect(foo).to receive(:bar).at_most(2).times
+
+# good
+expect(foo).to receive(:bar).once
+expect(foo).to receive(:bar).twice
+expect(foo).to receive(:bar).at_least(:once)
+expect(foo).to receive(:bar).at_least(:twice)
+expect(foo).to receive(:bar).at_most(:once)
+expect(foo).to receive(:bar).at_most(:twice).times
+----
+
+[#references-rspecreceivecounts]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts
+
+[#rspecreceivemessages]
+== RSpec/ReceiveMessages
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always (Unsafe)
+| 2.23
+| -
+|===
+
+Prefer `receive_messages` over multiple `receive`s on the same object.
+
+[#safety-rspecreceivemessages]
+=== Safety
+
+The autocorrection is marked as unsafe, because it may change the
+order of stubs. This in turn may cause e.g. variables to be called
+before they are defined.
+
+[#examples-rspecreceivemessages]
+=== Examples
+
+[source,ruby]
+----
+# bad
+before do
+  allow(Service).to receive(:foo).and_return(bar)
+  allow(Service).to receive(:baz).and_return(qux)
+end
+
+# good
+before do
+  allow(Service).to receive_messages(foo: bar, baz: qux)
+end
+
+# good - ignore same message
+before do
+  allow(Service).to receive(:foo).and_return(bar)
+  allow(Service).to receive(:foo).and_return(qux)
+end
+----
+
+[#references-rspecreceivemessages]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveMessages
+
+[#rspecreceivenever]
+== RSpec/ReceiveNever
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.28
+| -
+|===
+
+Prefer `not_to receive(...)` over `receive(...).never`.
+
+[#examples-rspecreceivenever]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to receive(:bar).never
+
+# good
+expect(foo).not_to receive(:bar)
+----
+
+[#references-rspecreceivenever]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever
+
+[#rspecredundantaround]
+== RSpec/RedundantAround
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.19
+| -
+|===
+
+Remove redundant `around` hook.
+
+[#examples-rspecredundantaround]
+=== Examples
+
+[source,ruby]
+----
+# bad
+around do |example|
+  example.run
+end
+
+# good
+----
+
+[#references-rspecredundantaround]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RedundantAround
+
+[#rspecredundantpredicatematcher]
+== RSpec/RedundantPredicateMatcher
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.26
+| -
+|===
+
+Checks for redundant predicate matcher.
+
+[#examples-rspecredundantpredicatematcher]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to be_exist(bar)
+expect(foo).not_to be_include(bar)
+expect(foo).to be_all(bar)
+
+# good
+expect(foo).to exist(bar)
+expect(foo).not_to include(bar)
+expect(foo).to all be(bar)
+----
+
+[#references-rspecredundantpredicatematcher]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RedundantPredicateMatcher
+
+[#rspecremoveconst]
+== RSpec/RemoveConst
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.26
+| -
+|===
+
+Checks that `remove_const` is not used in specs.
+
+[#examples-rspecremoveconst]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it 'does something' do
+  Object.send(:remove_const, :SomeConstant)
+end
+
+before do
+  SomeClass.send(:remove_const, :SomeConstant)
+end
+----
+
+[#references-rspecremoveconst]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RemoveConst
+
+[#rspecrepeateddescription]
+== RSpec/RepeatedDescription
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.9
+| -
+|===
+
+Check for repeated description strings in example groups.
+
+[#examples-rspecrepeateddescription]
+=== Examples
+
+[source,ruby]
+----
+# bad
+RSpec.describe User do
+  it 'is valid' do
+    # ...
+  end
+
+  it 'is valid' do
+    # ...
+  end
+end
+
+# good
+RSpec.describe User do
+  it 'is valid when first and last name are present' do
+    # ...
+  end
+
+  it 'is valid when last name only is present' do
+    # ...
+  end
+end
+
+# good
+RSpec.describe User do
+  it 'is valid' do
+    # ...
+  end
+
+  it 'is valid', :flag do
+    # ...
+  end
+end
+----
+
+[#references-rspecrepeateddescription]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription
+
+[#rspecrepeatedexample]
+== RSpec/RepeatedExample
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.10
+| -
+|===
+
+Check for repeated examples within example groups.
+
+[#examples-rspecrepeatedexample]
+=== Examples
+
+[source,ruby]
+----
+it 'is valid' do
+  expect(user).to be_valid
+end
+
+it 'validates the user' do
+  expect(user).to be_valid
+end
+----
+
+[#references-rspecrepeatedexample]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample
+
+[#rspecrepeatedexamplegroupbody]
+== RSpec/RepeatedExampleGroupBody
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.38
+| -
+|===
+
+Check for repeated describe and context block body.
+
+[#examples-rspecrepeatedexamplegroupbody]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe 'cool feature x' do
+  it { cool_predicate }
+end
+
+describe 'cool feature y' do
+  it { cool_predicate }
+end
+
+# good
+describe 'cool feature' do
+  it { cool_predicate }
+end
+
+describe 'another cool feature' do
+  it { another_predicate }
+end
+
+# good
+context 'when case x', :tag do
+  it { cool_predicate }
+end
+
+context 'when case y' do
+  it { cool_predicate }
+end
+
+# good
+context Array do
+  it { is_expected.to respond_to :each }
+end
+
+context Hash do
+  it { is_expected.to respond_to :each }
+end
+----
+
+[#references-rspecrepeatedexamplegroupbody]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody
+
+[#rspecrepeatedexamplegroupdescription]
+== RSpec/RepeatedExampleGroupDescription
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.38
+| -
+|===
+
+Check for repeated example group descriptions.
+
+[#examples-rspecrepeatedexamplegroupdescription]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe 'cool feature' do
+  # example group
+end
+
+describe 'cool feature' do
+  # example group
+end
+
+# bad
+context 'when case x' do
+  # example group
+end
+
+describe 'when case x' do
+  # example group
+end
+
+# good
+describe 'cool feature' do
+  # example group
+end
+
+describe 'another cool feature' do
+  # example group
+end
+
+# good
+context 'when case x' do
+  # example group
+end
+
+context 'when another case' do
+  # example group
+end
+----
+
+[#references-rspecrepeatedexamplegroupdescription]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription
+
+[#rspecrepeatedincludeexample]
+== RSpec/RepeatedIncludeExample
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.44
+| -
+|===
+
+Check for repeated include of shared examples.
+
+[#examples-rspecrepeatedincludeexample]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe 'foo' do
+  include_examples 'cool stuff'
+  include_examples 'cool stuff'
+end
+
+# bad
+describe 'foo' do
+  it_behaves_like 'a cool', 'thing'
+  it_behaves_like 'a cool', 'thing'
+end
+
+# bad
+context 'foo' do
+  it_should_behave_like 'a duck'
+  it_should_behave_like 'a duck'
+end
+
+# good
+describe 'foo' do
+  include_examples 'cool stuff'
+end
+
+describe 'bar' do
+  include_examples 'cool stuff'
+end
+
+# good
+describe 'foo' do
+  it_behaves_like 'a cool', 'thing'
+  it_behaves_like 'a cool', 'person'
+end
+
+# good
+context 'foo' do
+  it_should_behave_like 'a duck'
+  it_should_behave_like 'a goose'
+end
+----
+
+[#references-rspecrepeatedincludeexample]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedIncludeExample
+
+[#rspecrepeatedsubjectcall]
+== RSpec/RepeatedSubjectCall
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.27
+| -
+|===
+
+Checks for repeated calls to subject missing that it is memoized.
+
+[#examples-rspecrepeatedsubjectcall]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it do
+  subject
+  expect { subject }.to not_change { A.count }
+end
+
+it do
+  expect { subject }.to change { A.count }
+  expect { subject }.to not_change { A.count }
+end
+
+# good
+it do
+  expect { my_method }.to change { A.count }
+  expect { my_method }.to not_change { A.count }
+end
+
+# also good
+it do
+  expect { subject.a }.to change { A.count }
+  expect { subject.b }.to not_change { A.count }
+end
+----
+
+[#references-rspecrepeatedsubjectcall]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedSubjectCall
+
+[#rspecreturnfromstub]
+== RSpec/ReturnFromStub
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.16
+| 1.22
+|===
+
+Checks for consistent style of stub's return setting.
+
+Enforces either `and_return` or block-style return in the cases
+where the returned value is constant. Ignores dynamic returned values
+are the result would be different
+
+This cop can be configured using the `EnforcedStyle` option
+
+[#examples-rspecreturnfromstub]
+=== Examples
+
+[#_enforcedstyle_-and_return_-_default_-rspecreturnfromstub]
+==== `EnforcedStyle: and_return` (default)
+
+[source,ruby]
+----
+# bad
+allow(Foo).to receive(:bar) { "baz" }
+expect(Foo).to receive(:bar) { "baz" }
+
+# good
+allow(Foo).to receive(:bar).and_return("baz")
+expect(Foo).to receive(:bar).and_return("baz")
+# also good as the returned value is dynamic
+allow(Foo).to receive(:bar) { bar.baz }
+----
+
+[#_enforcedstyle_-block_-rspecreturnfromstub]
+==== `EnforcedStyle: block`
+
+[source,ruby]
+----
+# bad
+allow(Foo).to receive(:bar).and_return("baz")
+expect(Foo).to receive(:bar).and_return("baz")
+
+# good
+allow(Foo).to receive(:bar) { "baz" }
+expect(Foo).to receive(:bar) { "baz" }
+# also good as the returned value is dynamic
+allow(Foo).to receive(:bar).and_return(bar.baz)
+----
+
+[#configurable-attributes-rspecreturnfromstub]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `and_return`
+| `and_return`, `block`
+|===
+
+[#references-rspecreturnfromstub]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub
+
+[#rspecscatteredlet]
+== RSpec/ScatteredLet
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.14
+| 2.31
+|===
+
+Checks for let scattered across the example group.
+
+Group lets together
+
+[#examples-rspecscatteredlet]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe Foo do
+  let(:foo) { 1 }
+  subject { Foo }
+  let(:bar) { 2 }
+  before { prepare }
+  let!(:baz) { 3 }
+end
+
+# good
+describe Foo do
+  subject { Foo }
+  before { prepare }
+  let(:foo) { 1 }
+  let(:bar) { 2 }
+  let!(:baz) { 3 }
+end
+----
+
+[#references-rspecscatteredlet]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet
+
+[#rspecscatteredsetup]
+== RSpec/ScatteredSetup
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Command-line only
+| 1.10
+| 2.31
+|===
+
+Checks for setup scattered across multiple hooks in an example group.
+
+Unify `before` and `after` hooks when possible.
+However, `around` hooks are allowed to be defined multiple times,
+as unifying them would typically make the code harder to read.
+
+[#examples-rspecscatteredsetup]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe Foo do
+  before { setup1 }
+  before { setup2 }
+end
+
+# good
+describe Foo do
+  before do
+    setup1
+    setup2
+  end
+end
+
+# good
+describe Foo do
+  around { |example| before1; example.call; after1 }
+  around { |example| before2; example.call; after2 }
+end
+----
+
+[#references-rspecscatteredsetup]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup
+
+[#rspecsharedcontext]
+== RSpec/SharedContext
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.13
+| -
+|===
+
+Checks for proper shared_context and shared_examples usage.
+
+If there are no examples defined, use shared_context.
+If there is no setup defined, use shared_examples.
+
+[#examples-rspecsharedcontext]
+=== Examples
+
+[source,ruby]
+----
+# bad
+RSpec.shared_context 'only examples here' do
+  it 'does x' do
+  end
+
+  it 'does y' do
+  end
+end
+
+# good
+RSpec.shared_examples 'only examples here' do
+  it 'does x' do
+  end
+
+  it 'does y' do
+  end
+end
+----
+
+[source,ruby]
+----
+# bad
+RSpec.shared_examples 'only setup here' do
+  subject(:foo) { :bar }
+
+  let(:baz) { :bazz }
+
+  before do
+    something
+  end
+end
+
+# good
+RSpec.shared_context 'only setup here' do
+  subject(:foo) { :bar }
+
+  let(:baz) { :bazz }
+
+  before do
+    something
+  end
+end
+----
+
+[#references-rspecsharedcontext]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext
+
+[#rspecsharedexamples]
+== RSpec/SharedExamples
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.25
+| 2.26
+|===
+
+Checks for consistent style for shared example names.
+
+Enforces either `string` or `symbol` for shared example names.
+
+This cop can be configured using the `EnforcedStyle` option
+
+[#examples-rspecsharedexamples]
+=== Examples
+
+[#_enforcedstyle_-string_-_default_-rspecsharedexamples]
+==== `EnforcedStyle: string` (default)
+
+[source,ruby]
+----
+# bad
+it_behaves_like :foo_bar_baz
+it_should_behave_like :foo_bar_baz
+shared_examples :foo_bar_baz
+shared_examples_for :foo_bar_baz
+include_examples :foo_bar_baz
+
+# good
+it_behaves_like 'foo bar baz'
+it_should_behave_like 'foo bar baz'
+shared_examples 'foo bar baz'
+shared_examples_for 'foo bar baz'
+include_examples 'foo bar baz'
+----
+
+[#_enforcedstyle_-symbol_-rspecsharedexamples]
+==== `EnforcedStyle: symbol`
+
+[source,ruby]
+----
+# bad
+it_behaves_like 'foo bar baz'
+it_should_behave_like 'foo bar baz'
+shared_examples 'foo bar baz'
+shared_examples_for 'foo bar baz'
+include_examples 'foo bar baz'
+
+# good
+it_behaves_like :foo_bar_baz
+it_should_behave_like :foo_bar_baz
+shared_examples :foo_bar_baz
+shared_examples_for :foo_bar_baz
+include_examples :foo_bar_baz
+----
+
+[#configurable-attributes-rspecsharedexamples]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `string`
+| `string`, `symbol`
+|===
+
+[#references-rspecsharedexamples]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples
+
+[#rspecsingleargumentmessagechain]
+== RSpec/SingleArgumentMessageChain
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.9
+| 1.10
+|===
+
+Checks that chains of messages contain more than one element.
+
+[#examples-rspecsingleargumentmessagechain]
+=== Examples
+
+[source,ruby]
+----
+# bad
+allow(foo).to receive_message_chain(:bar).and_return(42)
+
+# good
+allow(foo).to receive(:bar).and_return(42)
+
+# also good
+allow(foo).to receive(:bar, :baz)
+allow(foo).to receive("bar.baz")
+----
+
+[#references-rspecsingleargumentmessagechain]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain
+
+[#rspecskipblockinsideexample]
+== RSpec/SkipBlockInsideExample
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.19
+| -
+|===
+
+Checks for passing a block to `skip` within examples.
+
+[#examples-rspecskipblockinsideexample]
+=== Examples
+
+[source,ruby]
+----
+# bad
+it 'does something' do
+  skip 'not yet implemented' do
+    do_something
+  end
+end
+
+# good
+it 'does something' do
+  skip 'not yet implemented'
+  do_something
+end
+
+# good - when outside example
+skip 'not yet implemented' do
+end
+----
+
+[#references-rspecskipblockinsideexample]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SkipBlockInsideExample
+
+[#rspecsortmetadata]
+== RSpec/SortMetadata
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 2.14
+| -
+|===
+
+Sort RSpec metadata alphabetically.
+
+Only the trailing metadata is sorted.
+
+[#examples-rspecsortmetadata]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe 'Something', :b, :a
+context 'Something', foo: 'bar', baz: true
+it 'works', :b, :a, foo: 'bar', baz: true
+
+# good
+describe 'Something', :a, :b
+context 'Something', baz: true, foo: 'bar'
+it 'works', :a, :b, baz: true, foo: 'bar'
+
+# good, trailing metadata is sorted
+describe 'Something', 'description', :a, :b, :z
+context 'Something', :z, variable, :a, :b
+----
+
+[#references-rspecsortmetadata]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SortMetadata
+
+[#rspecspecfilepathformat]
+== RSpec/SpecFilePathFormat
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.24
+| -
+|===
+
+Checks that spec file paths are consistent and well-formed.
+
+[#examples-rspecspecfilepathformat]
+=== Examples
+
+[source,ruby]
+----
+# bad
+whatever_spec.rb         # describe MyClass
+my_class_spec.rb         # describe MyClass, '#method'
+
+# good
+my_class_spec.rb         # describe MyClass
+my_class_method_spec.rb  # describe MyClass, '#method'
+my_class/method_spec.rb  # describe MyClass, '#method'
+----
+
+[#_customtransform_-_rubocop__rubocop_-rspec__rspec__-_default_-rspecspecfilepathformat]
+==== `CustomTransform: {RuboCop=>rubocop, RSpec=>rspec}` (default)
+
+[source,ruby]
+----
+# good
+rubocop_spec.rb          # describe RuboCop
+rspec_spec.rb            # describe RSpec
+----
+
+[#_ignoremethods_-false_-_default_-rspecspecfilepathformat]
+==== `IgnoreMethods: false` (default)
+
+[source,ruby]
+----
+# bad
+my_class_spec.rb         # describe MyClass, '#method'
+----
+
+[#_ignoremethods_-true_-rspecspecfilepathformat]
+==== `IgnoreMethods: true`
+
+[source,ruby]
+----
+# good
+my_class_spec.rb         # describe MyClass, '#method'
+----
+
+[#_ignoremetadata_-_type__routing__-_default_-rspecspecfilepathformat]
+==== `IgnoreMetadata: {type=>routing}` (default)
+
+[source,ruby]
+----
+# good
+whatever_spec.rb         # describe MyClass, type: :routing do; end
+----
+
+[#configurable-attributes-rspecspecfilepathformat]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Include
+| `+**/*_spec.rb+`
+| Array
+
+| Exclude
+| `+**/spec/routing/**/*+`
+| Array
+
+| CustomTransform
+| `{"RuboCop" => "rubocop", "RSpec" => "rspec"}`
+| 
+
+| IgnoreMethods
+| `false`
+| Boolean
+
+| IgnoreMetadata
+| `{"type" => "routing"}`
+| 
+|===
+
+[#references-rspecspecfilepathformat]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathFormat
+
+[#rspecspecfilepathsuffix]
+== RSpec/SpecFilePathSuffix
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.24
+| -
+|===
+
+Checks that spec file paths suffix are consistent and well-formed.
+
+[#examples-rspecspecfilepathsuffix]
+=== Examples
+
+[source,ruby]
+----
+# bad
+my_class/foo_specorb.rb   # describe MyClass
+spec/models/user.rb       # describe User
+spec/models/user_specxrb  # describe User
+
+# good
+my_class_spec.rb          # describe MyClass
+
+# good - shared examples are allowed
+spec/models/user.rb       # shared_examples_for 'foo'
+----
+
+[#configurable-attributes-rspecspecfilepathsuffix]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Include
+| `+**/*_spec*rb*+`, `+**/spec/**/*+`
+| Array
+|===
+
+[#references-rspecspecfilepathsuffix]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SpecFilePathSuffix
+
+[#rspecstubbedmock]
+== RSpec/StubbedMock
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.44
+| -
+|===
+
+Checks that message expectations do not have a configured response.
+
+[#examples-rspecstubbedmock]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(foo).to receive(:bar).with(42).and_return("hello world")
+
+# good (without spies)
+allow(foo).to receive(:bar).with(42).and_return("hello world")
+expect(foo).to receive(:bar).with(42)
+----
+
+[#references-rspecstubbedmock]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/StubbedMock
+
+[#rspecsubjectdeclaration]
+== RSpec/SubjectDeclaration
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.5
+| -
+|===
+
+Ensure that subject is defined using subject helper.
+
+[#examples-rspecsubjectdeclaration]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:subject) { foo }
+let!(:subject) { foo }
+subject(:subject) { foo }
+subject!(:subject) { foo }
+
+# bad
+block = -> {}
+let(:subject, &block)
+
+# good
+subject(:test_subject) { foo }
+----
+
+[#references-rspecsubjectdeclaration]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectDeclaration
+
+[#rspecsubjectstub]
+== RSpec/SubjectStub
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.7
+| 2.8
+|===
+
+Checks for stubbed test subjects.
+
+Checks nested subject stubs for innermost subject definition
+when subject is also defined in parent example groups.
+
+[#examples-rspecsubjectstub]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe Article do
+  subject(:article) { Article.new }
+
+  it 'indicates that the author is unknown' do
+    allow(article).to receive(:author).and_return(nil)
+    expect(article.description).to include('by an unknown author')
+  end
+end
+
+# bad
+describe Article do
+  subject(:foo) { Article.new }
+
+  context 'nested subject' do
+    subject(:article) { Article.new }
+
+    it 'indicates that the author is unknown' do
+      allow(article).to receive(:author).and_return(nil)
+      expect(article.description).to include('by an unknown author')
+    end
+  end
+end
+
+# good
+describe Article do
+  subject(:article) { Article.new(author: nil) }
+
+  it 'indicates that the author is unknown' do
+    expect(article.description).to include('by an unknown author')
+  end
+end
+----
+
+[#references-rspecsubjectstub]
+=== References
+
+* https://rspec.rubystyle.guide/#dont-stub-subject
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub
+* https://robots.thoughtbot.com/don-t-stub-the-system-under-test
+* https://penelope.zone/2015/12/27/introducing-rspec-smells-and-where-to-find-them.html#smell-1-stubjec
+
+[#rspecundescriptiveliteralsdescription]
+== RSpec/UndescriptiveLiteralsDescription
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 2.29
+| -
+|===
+
+Description should be descriptive.
+
+If example group or example contains only `execute string`, numbers
+and regular expressions, the description is not clear.
+
+[#examples-rspecundescriptiveliteralsdescription]
+=== Examples
+
+[source,ruby]
+----
+# bad
+describe `time` do
+ # ...
+end
+
+# bad
+context /when foo/ do
+  # ...
+end
+
+# bad
+it 10000 do
+  # ...
+end
+
+# good
+describe Foo do
+  # ...
+end
+
+# good
+describe '#foo' do
+  # ...
+end
+
+# good
+context "when #{foo} is bar" do
+  # ...
+end
+
+# good
+it 'does something' do
+  # ...
+end
+----
+
+[#references-rspecundescriptiveliteralsdescription]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UndescriptiveLiteralsDescription
+
+[#rspecunspecifiedexception]
+== RSpec/UnspecifiedException
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.30
+| -
+|===
+
+Checks for a specified error in checking raised errors.
+
+Enforces one of an Exception type, a string, or a regular
+expression to match against the exception message as a parameter
+to `raise_error`
+
+[#examples-rspecunspecifiedexception]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect {
+  raise StandardError.new('error')
+}.to raise_error
+
+# good
+expect {
+  raise StandardError.new('error')
+}.to raise_error(StandardError)
+
+expect {
+  raise StandardError.new('error')
+}.to raise_error('error')
+
+expect {
+  raise StandardError.new('error')
+}.to raise_error(/err/)
+
+expect { do_something }.not_to raise_error
+----
+
+[#references-rspecunspecifiedexception]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException
+
+[#rspecvariabledefinition]
+== RSpec/VariableDefinition
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.40
+| -
+|===
+
+Checks that memoized helpers names are symbols or strings.
+
+[#examples-rspecvariabledefinition]
+=== Examples
+
+[#enforcedstyle_-symbols-_default_-rspecvariabledefinition]
+==== EnforcedStyle: symbols (default)
+
+[source,ruby]
+----
+# bad
+subject('user') { create_user }
+let('user_name') { 'Adam' }
+
+# good
+subject(:user) { create_user }
+let(:user_name) { 'Adam' }
+----
+
+[#enforcedstyle_-strings-rspecvariabledefinition]
+==== EnforcedStyle: strings
+
+[source,ruby]
+----
+# bad
+subject(:user) { create_user }
+let(:user_name) { 'Adam' }
+
+# good
+subject('user') { create_user }
+let('user_name') { 'Adam' }
+----
+
+[#configurable-attributes-rspecvariabledefinition]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `symbols`
+| `symbols`, `strings`
+|===
+
+[#references-rspecvariabledefinition]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableDefinition
+
+[#rspecvariablename]
+== RSpec/VariableName
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.40
+| 2.13
+|===
+
+Checks that memoized helper names use the configured style.
+
+Variables can be excluded from checking using the `AllowedPatterns`
+option.
+
+[#examples-rspecvariablename]
+=== Examples
+
+[#enforcedstyle_-snake_case-_default_-rspecvariablename]
+==== EnforcedStyle: snake_case (default)
+
+[source,ruby]
+----
+# bad
+subject(:userName1) { 'Adam' }
+let(:userName2) { 'Adam' }
+
+# good
+subject(:user_name_1) { 'Adam' }
+let(:user_name_2) { 'Adam' }
+----
+
+[#enforcedstyle_-camelcase-rspecvariablename]
+==== EnforcedStyle: camelCase
+
+[source,ruby]
+----
+# bad
+subject(:user_name_1) { 'Adam' }
+let(:user_name_2) { 'Adam' }
+
+# good
+subject(:userName1) { 'Adam' }
+let(:userName2) { 'Adam' }
+----
+
+[#allowedpatterns-configuration-rspecvariablename]
+==== AllowedPatterns configuration
+
+[source,ruby]
+----
+# rubocop.yml
+# RSpec/VariableName:
+#   EnforcedStyle: snake_case
+#   AllowedPatterns:
+#     - ^userFood
+----
+
+[source,ruby]
+----
+# okay because it matches the `^userFood` regex in `AllowedPatterns`
+subject(:userFood_1) { 'spaghetti' }
+let(:userFood_2) { 'fettuccine' }
+----
+
+[#configurable-attributes-rspecvariablename]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `snake_case`
+| `snake_case`, `camelCase`
+
+| AllowedPatterns
+| `[]`
+| Array
+|===
+
+[#references-rspecvariablename]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VariableName
+
+[#rspecverifieddoublereference]
+== RSpec/VerifiedDoubleReference
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always (Unsafe)
+| 2.10.0
+| 3.4
+|===
+
+Checks for consistent verified double reference style.
+
+[#safety-rspecverifieddoublereference]
+=== Safety
+
+This cop is unsafe because the correction requires loading the class.
+Loading before stubbing causes RSpec to only allow instance methods
+to be stubbed.
+
+[#examples-rspecverifieddoublereference]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) do
+  instance_double('ClassName', method_name: 'returned_value')
+end
+
+# good
+let(:foo) do
+  instance_double(ClassName, method_name: 'returned_value')
+end
+----
+
+[#reference-is-any-dynamic-variable_-no-enforcement-rspecverifieddoublereference]
+==== Reference is any dynamic variable. No enforcement
+
+[source,ruby]
+----
+# good
+let(:foo) do
+  instance_double(@klass, method_name: 'returned_value')
+end
+----
+
+[#references-rspecverifieddoublereference]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubleReference
+* https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+
+[#rspecverifieddoubles]
+== RSpec/VerifiedDoubles
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.2.1
+| 1.5
+|===
+
+Prefer using verifying doubles over normal doubles.
+
+[#examples-rspecverifieddoubles]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:foo) do
+  double(method_name: 'returned value')
+end
+
+# bad
+let(:foo) do
+  double("ClassName", method_name: 'returned value')
+end
+
+# good
+let(:foo) do
+  instance_double("ClassName", method_name: 'returned value')
+end
+----
+
+[#configurable-attributes-rspecverifieddoubles]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| IgnoreNameless
+| `true`
+| Boolean
+
+| IgnoreSymbolicNames
+| `false`
+| Boolean
+|===
+
+[#references-rspecverifieddoubles]
+=== References
+
+* https://rspec.rubystyle.guide/#doubles
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles
+* https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+
+[#rspecvoidexpect]
+== RSpec/VoidExpect
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 1.16
+| -
+|===
+
+Checks void `expect()`.
+
+[#examples-rspecvoidexpect]
+=== Examples
+
+[source,ruby]
+----
+# bad
+expect(something)
+
+# good
+expect(something).to be(1)
+----
+
+[#references-rspecvoidexpect]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect
+
+[#rspecyield]
+== RSpec/Yield
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| Always
+| 1.32
+| -
+|===
+
+Checks for calling a block within a stub.
+
+[#examples-rspecyield]
+=== Examples
+
+[source,ruby]
+----
+# bad
+allow(foo).to receive(:bar) { |&block| block.call(1) }
+
+# good
+expect(foo).to receive(:bar).and_yield(1)
+----
+
+[#references-rspecyield]
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield
diff --git a/docs/modules/ROOT/pages/development.adoc b/docs/modules/ROOT/pages/development.adoc
new file mode 100644
index 000000000..308980d8b
--- /dev/null
+++ b/docs/modules/ROOT/pages/development.adoc
@@ -0,0 +1,73 @@
+= Development
+
+This page describes considerations when developing RSpec-specific cops. It is intended to be a complement to the general https://docs.rubocop.org/rubocop/development.html[RuboCop development documentation].
+
+== Create a new cop
+
+NOTE: Clone the repository and run `bundle install` if not done yet.
+The following rake task can only be run inside the rubocop project directory itself.
+
+Use the bundled rake task `new_cop` to generate a cop template:
+
+[source,sh]
+----
+$ bundle exec rake 'new_cop[RSpec/CopName]'
+[create] lib/rubocop/cop/rspec/cop_name.rb
+[create] spec/rubocop/cop/rspec/cop_name_spec.rb
+[modify] lib/rubocop/cop/rspec_cops.rb - `require_relative 'rspec/cop_name'` was injected.
+[modify] A configuration for the cop is added into config/default.yml.
+Do 4 steps:
+  1. Modify the description of RSpec/CopName in config/default.yml
+  2. Implement your new cop in the generated file!
+  3. Add an entry about new cop to CHANGELOG.md
+  4. Commit your new cop with a message such as
+     e.g. "Add new `#{badge}` cop"
+----
+
+=== Choose a Name
+
+Use the following rules to give the new cop a name:
+
+* Pick a department. See the xref:cops.adoc[list of existing departments]
+* The name is self-explanatory
+* The name explains the offense the cop detects, e.g. `ExtraSpacing`
+* The name starts with a noun instead of a verb, e.g. `ArrayAlignment` instead of `AlignArray`
+* The name is easy to understand, e.g. `IndentationStyle` instead of just `Tab`
+* The name is specific, e.g. `DuplicateHashKey` instead of just `DuplicateKey`
+* The name is neutral when possible and accommodates multiple styles when feasible, e.g. `EmptyLineBeforeBegin`.
+* The name uses commonly-used terms, e.g. `RedundantPercentI` instead of `RedundantPercentSymbolArray`
+* The name uses correct terms, e.g. arguments in a method call, and parameters in a method signature
+* Lines with no symbols are called "empty", not "blank", e.g. `LeadingEmptyLines` instead of `LeadingBlankLines`
+* Prefer "redundant" to "unneeded", e.g. `RedundantSelf` instead of `UnneededSelf`
+
+See the https://github.com/rubocop/rubocop/blob/12fd014e255617a08b7b42aa5df0745e7382af88/config/obsoletion.yml#L4["renamed" section of `config/obsoletion.yml`]
+for good and bad examples (old name is on the left, new name on the right).
+
+== Base class
+
+The `RuboCop::Cop::RSpec::Base` class includes convenient https://docs.rubocop.org/rubocop-ast/node_pattern.html[node pattern DSL] matchers that will automatically account for any xref:usage.adoc#rspec-dsl-configuration[custom RSpec DSL configuration].
+
+For example, if the project defines https://github.com/test-prof/test-prof/blob/master/docs/recipes/let_it_be.md[`let_it_be`] as a `Helper`, then all cops will find `let_it_be` when using the `let?` matcher.
+
+== Writing specs
+
+When working on RSpec-specific cops, ensure that the https://github.com/rubocop/rubocop-rspec/blob/master/config/default.yml[default language config] is loaded for all RSpec specs. For example:
+
+[source,ruby]
+----
+require 'rubocop/rspec/shared_contexts/default_rspec_language_config_context'
+
+RSpec.config do |config|
+  # Set metadata on all cop specs
+  config.define_derived_metadata(file_path: %r{/spec/rubocop/cop/}) do |meta|
+    meta[:type] = :cop_spec
+  end
+
+  # Include RuboCop's config shared context for all cop specs
+  config.define_derived_metadata(type: :cop_spec) do |meta|
+    meta[:config] = true
+  end
+
+  config.include_context 'with default RSpec/Language config', :config
+end
+----
diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc
new file mode 100644
index 000000000..e6a27ef5c
--- /dev/null
+++ b/docs/modules/ROOT/pages/index.adoc
@@ -0,0 +1,59 @@
+= RuboCop RSpec
+
+https://rspec.info/[RSpec]-specific analysis for your projects, as an extension to
+https://github.com/rubocop/rubocop[RuboCop].
+
+RuboCop RSpec follows the https://docs.rubocop.org/rubocop/versioning.html[RuboCop versioning guide].
+In a nutshell, between major versions new cops are introduced in a special `pending` status.
+That means that they won't be run unless explicitly told otherwise.
+RuboCop will warn on start that certain cops are neither explicitly enabled and disabled.
+On a major version release, all `pending` cops are enabled.
+
+== Project Goals
+
+* Enforce the guidelines and best practices outlined in the community https://rspec.rubystyle.guide[RSpec style guide]
+* Simplify the process of adopting new RSpec functionality
+
+== Non-goals of RuboCop RSpec
+
+=== Enforcing `should` vs. `expect` syntax
+
+Enforcing
+
+[source,ruby]
+----
+expect(calculator.compute(line_item)).to eq(5)
+----
+
+over
+
+[source,ruby]
+----
+calculator.compute(line_item).should == 5
+----
+
+is a feature of RSpec itself - you can read about it in the "Disable should syntax" section of https://rspec.info/features/3-12/rspec-expectations/syntax-configuration[RSpec Documentation].
+
+=== Enforcing an explicit RSpec receiver for top-level methods (disabling monkey patching)
+
+Enforcing
+
+[source,ruby]
+----
+RSpec.describe MyClass do
+  ...
+end
+----
+
+over
+
+[source,ruby]
+----
+describe MyClass do
+  ...
+end
+----
+
+can be achieved using RSpec's `disable_monkey_patching!` method, which you can read more about in the https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode[RSpec Documentation]. This will also prevent `should` from being defined on every object in your system.
+
+Before disabling `should` you will need all your specs to use the `expect` syntax. You can use http://yujinakayama.me/transpec/[Transpec], which will do the conversion for you.
diff --git a/manual/installation.md b/docs/modules/ROOT/pages/installation.adoc
similarity index 67%
rename from manual/installation.md
rename to docs/modules/ROOT/pages/installation.adoc
index 5c26d5ce4..dda8f545d 100644
--- a/manual/installation.md
+++ b/docs/modules/ROOT/pages/installation.adoc
@@ -1,11 +1,15 @@
+= Installation
+
 Just install the `rubocop-rspec` gem
 
-```bash
+[source,bash]
+----
 gem install rubocop-rspec
-```
+----
 
 or if you use bundler put this in your `Gemfile`
 
-```ruby
+[source,ruby]
+----
 gem 'rubocop-rspec'
-```
+----
diff --git a/docs/modules/ROOT/pages/third_party_rspec_syntax_extensions.adoc b/docs/modules/ROOT/pages/third_party_rspec_syntax_extensions.adoc
new file mode 100644
index 000000000..bb6825eba
--- /dev/null
+++ b/docs/modules/ROOT/pages/third_party_rspec_syntax_extensions.adoc
@@ -0,0 +1,28 @@
+= RSpec syntax extensions in third-party gems
+
+Some gems, e.g. https://github.com/CanCanCommunity/cancancan[cancancan], https://github.com/palkan/action_policy[action_policy] and https://github.com/varvet/pundit[pundit] provide their own extensions and aliases to RSpec syntax. Also, RSpec extensions like https://github.com/palkan/test-prof[test-prof], https://github.com/rspec/rspec-its[rspec-its] and https://github.com/zverok/saharspec#its-addons[saharspec] do.
+
+By default, RuboCop RSpec is not aware of those syntax extensions, and does not intend to gather all of them in the default configuration file.
+It is possible for the gems to provide configuration for RuboCop RSpec to allow proper detection of RSpec elements.
+RuboCop https://docs.rubocop.org/rubocop/configuration.html#inheriting-configuration-from-a-dependency-gem[provides third-party gems with an ability to configure RuboCop].
+
+== Packaging configuration for RuboCop RSpec
+
+NOTE: Due to https://github.com/rubocop/rubocop-rspec/issues/1126[a bug], this feature doesn't work properly for `rubocop-rspec` 2.5.0 and earlier versions.
+
+For a third-party gem, it's sufficient to follow three steps:
+
+1. Provide a configuration file (e.g. `.rubocop_rspec_alias_config.yml` or `config/rubocop-rspec.yml`).
+Please check with the xref:usage.adoc#rspec-dsl-configuration[RSpec DSL configuration] how different elements of RSpec syntax can be configured.
+
+2. Add a section to their documentation how users can benefit from using RuboCop RSpec with full detection of their syntax extensions.
+   Example:
+
+    ## Usage with RuboCop RSpec
+    Please add the following to your `.rubocop.yml` to make RuboCop RSpec aware of our cool syntax extensions:
+      inherit_gem:
+        third-party-gem: .rubocop_rspec_alias_config.yml
+
+3. Include the configuration file to their package by updating their `gemspec`'s `spec.files` to include the aforementioned configuration file.
+
+See pull requests: https://github.com/test-prof/test-prof/pull/199[test-prof], and https://github.com/palkan/action_policy/pull/138[action_policy] for a less trivial example.
diff --git a/docs/modules/ROOT/pages/upgrade_to_version_2.adoc b/docs/modules/ROOT/pages/upgrade_to_version_2.adoc
new file mode 100644
index 000000000..2d91caa6e
--- /dev/null
+++ b/docs/modules/ROOT/pages/upgrade_to_version_2.adoc
@@ -0,0 +1,273 @@
+= Upgrade to Version 2.x
+:doctype: book
+
+== Configuration File Update
+
+In version 2.x:
+
+ - `RSpec/InvalidPredicateMatcher` cop is removed
+ - `CustomIncludeMethods` configuration option for `RSpec/EmptyExampleGroup` is removed
+ - cop departments are nested for cops with a department that doesn't match the extension name (`Capybara`, `FactoryBot`, `Rails`)
+ - `AllCops/RSpec/Patterns`/`AllCops/FactoryBot/Patterns` options are removed
+ - Calling `super` from `#on_new_investigation` defined in a cop is mandatory now
+ - In specs, do not define `cop`
+
+[discrete]
+=== Adjust the configuration of `RSpec/EmptyExampleGroup`
+
+[source,yaml]
+----
+# .rubocop.yml
+
+# Before
+RSpec/EmptyExampleGroup:
+  CustomIncludeMethods:
+    - include_tests
+
+# After
+RSpec:
+  Language:
+    Includes:
+      Examples:
+        - include_tests
+----
+
+=== Add a top-level `RSpec` department
+
+RuboCop extensions had cops with clashing names and departments, e.g. both `rspec-rails` and `rubocop-rspec` had `Rails::HttpStatus` cops.
+To avoid issues, e.g. inability to disable just one of the cops, each extension now has its own uber-department.
+Expectedly, RuboCop RSpec's uber-department name is `RSpec`.
+Changes are only applied to cops that don't already have the department set to `RSpec`, i.e. `Capybara`, `FactoryBot` and `Rails`.
+
+[source,yaml]
+----
+# .rubocop.yml
+
+# Before
+Capybara/CurrentPathExpectation:
+  Enabled: false
+
+FactoryBot/AttributeDefinedStatically:
+  Enabled: false
+
+# remains the same
+RSpec/EmptyExampleGroup:
+  Enabled: false
+
+# After
+RSpec/Capybara/CurrentPathExpectation:
+  Enabled: false
+
+RSpec/FactoryBot/AttributeDefinedStatically:
+  Enabled: false
+
+# remains the same
+RSpec/EmptyExampleGroup:
+  Enabled: false
+----
+
+https://github.com/rubocop/rubocop/pull/8490[Learn more about this change].
+
+
+=== Use the RuboCop standard `Include` option to filter inspected files
+
+`Patterns` was a RuboCop RSpec-specific option, and RuboCop has a standard replacement.
+
+[source,yaml]
+----
+# .rubocop.yml
+
+# Before
+AllCops:
+  RSpec/FactoryBot:
+    Patterns:
+      - spec/factories/**/*.rb
+      - property/factories/**/*.rb
+
+# After
+RSpec/FactoryBot:
+  Include:
+    - spec/factories/**/*.rb
+    - property/factories/**/*.rb
+----
+
+NOTE: Please keep in mind that merge mode for `Include` is set to override the default settings, so if you intend to add a path while keeping the default paths, you should include the default `Include` paths in your configuration.
+
+https://github.com/rubocop/rubocop-rspec/pull/1063[Learn more about this change].
+
+== Custom Cop Update Guide
+
+Due to significant API changes, custom cops may break.
+Here is the summary of the changes:
+
+1. The base class for cops is now `RuboCop::Cop::RSpec::Base` instead of `RuboCop::Cop::RSpec::Cop`.
+
+2. The module `RuboCop::Cop::RSpec::TopLevelDescribe` is replaced with a more generic `RuboCop::Cop::RSpec::TopLevelGroup`.
+
+3. `RuboCop::RSpec::Language` has been completely rewritten to support dynamic RSpec DSL aliases and negated matchers to fully support third-party libraries such as RSpec Rails, Pundit, Action Policy and many others.
+
+4. RuboCop RSpec updated the dependency of RuboCop to 1.0+.
+
+Below are the necessary steps to update custom cops to work with `rubocop-rspec` version 2.x.
+
+
+=== Change the Parent Class
+
+Change the parent class of the custom cops from `RuboCop::Cop::RSpec::Cop` to `RuboCop::Cop::RSpec::Base`.
+
+[source,ruby]
+----
+# Before
+module RuboCop
+  module Cop
+    module RSpec
+      class FightPowerty < Cop
+
+# After
+module RuboCop
+  module Cop
+    module RSpec
+      class FightPowerty < Base
+----
+
+https://github.com/rubocop/rubocop-rspec/pull/962[Example pull request].
+
+
+=== Replace `TopLevelDescribe`
+
+`TopLevelDescribe` was incomplete, had poor performance and did not distinguish between example groups and shared example groups.
+
+`TopLevelGroup` provides a similar interface, but instead of a single `on_top_level_describe` hook there are two, `on_top_level_example_group` and `on_top_level_group`.
+There's no need yet for `on_top_level_shared_group` for RuboCop core cops, but if your custom cop needs such a hook, please feel free to send a pull request.
+
+Additionally, `single_top_level_describe?` is removed with no direct replacement.
+You may use `top_level_groups` query method instead, e.g. `top_level_groups.one?`.
+
+Example pull requests to replace `TopLevelDescribe` with `TopLevelGroup` [https://github.com/rubocop/rubocop-rspec/pull/978[1], https://github.com/rubocop/rubocop-rspec/pull/932[2], https://github.com/rubocop/rubocop-rspec/pull/977[3]].
+
+
+=== Change the `Language` Module Usages
+
+To allow for lazy initialization, and for loading of the language configuration after the class are loaded, a https://docs.rubocop.org/rubocop-ast/node_pattern.html#to-call-functions[function call feature of RuboCop AST] is used.
+
+The `RuboCop::RSpec::Language` is completely different now.
+
+`Hooks::ALL` and alike, and their accompanying helpers work differently.
+
+[source,ruby]
+----
+# Before
+def_node_matcher :shared_context,
+                 SharedGroups::CONTEXT.block_pattern
+
+# After
+def_node_matcher :shared_context,
+                 '(block (send #rspec? #SharedGroups.context ...) ...)'
+----
+
+[source,ruby]
+----
+# Before
+def_node_search :examples?,
+                (Includes::EXAMPLES + Examples::ALL).send_pattern
+
+# After
+def_node_search :examples?,
+                '(send nil? {#Includes.examples #Examples.all} ...)'
+----
+
+[source,ruby]
+----
+# Before
+def_node_search :find_rspec_blocks,
+                ExampleGroups::ALL.block_pattern
+
+# After
+def_node_search :find_rspec_blocks,
+                '(block (send #rspec? #ExampleGroups.all ...) ...)'
+----
+
+If you were calling Language elements directly, you have to make the same adjustments:
+
+[source,ruby]
+----
+# Before
+node&.sym_type? && Hooks::Scopes::ALL.include?(node.value)
+
+# After
+node&.sym_type? && Language::HookScopes.all(node.value)
+----
+
+You may see a common pattern in the change.
+There is a small exception, though:
+
+[source,ruby]
+----
+# Before
+ExampleGroups::GROUPS
+
+# After
+ExampleGroups.regular
+
+# Before
+Examples::EXAMPLES
+
+# After
+Examples.regular
+----
+
+https://github.com/rubocop/rubocop-rspec/pull/956[Pull request with more examples].
+
+=== Always call `super` from `on_new_investigation` in your cops
+
+`on_new_investigation` is now used for internal purposes, and not calling `super` from your cop involves a risk of configuration not being properly loaded, and dynamic RSpec DSL matchers won't work.
+
+NOTE: You don't have to define `on_new_investigation` in your cops unless you need to.
+
+[source,ruby]
+----
+module RuboCop
+  module Cop
+    module RSpec
+      class MultipleMemoizedHelpers < Base
+        def on_new_investigation
+          super # Always call `super`
+          @example_group_memoized_helpers = {}
+        end
+      end
+    end
+  end
+end
+----
+
+https://github.com/rubocop/rubocop-rspec/pull/956[Pull request with more examples].
+
+=== Use `:config` RSpec metadata in cop specs
+
+`:config` metadata should be added to the top-level example group of your cop spec.
+Doing otherwise will not pass configuration to the cop, and dynamic RSpec DSL matchers might not work.
+
+[source,ruby]
+----
+# Before
+RSpec.describe 'MyMightyCop' do
+  let(:cop) { described_class.new }
+  # ...
+end
+
+# After
+RSpec.describe 'MyMightyCop', :config do
+  # `cop` is defined for you by RuboCop's shared context that is included
+  # to example groups with :config metadata
+
+  # ...
+end
+----
+
+https://github.com/rubocop/rubocop/blob/51ff1d7e29c985732fe129082c98d66c531a2611/lib/rubocop/rspec/shared_contexts.rb#L56[RuboCop takes care of defining everything for your cop specs].
+
+=== Conform with RuboCop API Changes
+
+The parent project, RuboCop, has API changes.
+While they won't result in cop breakages, it is recommended to update cops to use new API's.
+Follow the https://docs.rubocop.org/rubocop/v1_upgrade_notes[RuboCop v1 update guide] to adjust custom cops' use of RuboCop's auto-correction API.
diff --git a/docs/modules/ROOT/pages/upgrade_to_version_3.adoc b/docs/modules/ROOT/pages/upgrade_to_version_3.adoc
new file mode 100644
index 000000000..29de466d4
--- /dev/null
+++ b/docs/modules/ROOT/pages/upgrade_to_version_3.adoc
@@ -0,0 +1,60 @@
+= Upgrade to Version 3.x
+:doctype: book
+
+== Configuration File Update
+
+In version 3.x:
+
+ - cop departments are extracted to another gem. (`Capybara`, `FactoryBot`, `Rails`)
+
+[discrete]
+=== Extraction of cop departments. (`Capybara`, `FactoryBot`, `Rails`)
+
+If you are using the RSpec/Capybara, RSpec/FactoryBot, or RSpec/Rails departments -- or have one in a `require` list in your rubocop.yml -- you need to install the corresponding gem and add it to your `.rubocop.yml` file:
+
+* Capybara: `rubocop-capybara`
+* FactoryBot: `rubocop-factory_bot`
+* Rails: `rubocop-rspec_rails`
+
+For example, if you are using the RSpec/Capybara department, you need to install the `rubocop-capybara` gem and add it to your `.rubocop.yml` file:
+
+[source,ruby]
+----
+# Gemfile
+group :test do
+  gem 'rubocop-rspec'
+  gem 'rubocop-capybara'
+end
+----
+
+[source,yaml]
+----
+require:
+  - rubocop-rspec
+  - rubocop-capybara
+----
+
+And you need to remove the old department in your `.rubocop.yml` file:
+
+[source,yaml]
+----
+RSpec/Capybara:
+  Enabled: false
+----
+
+For another example, if you are not using these departments, you don't need to do anything.
+And when you update to RuboCop RSpec v3.0.0, you need to remove the old departments from your `.rubocop.yml` file, e.g.:
+
+[source,yaml]
+----
+RSpec/Capybara:
+  Enabled: false
+RSpec/FactoryBot:
+  Enabled: false
+RSpec/Rails:
+  Enabled: false
+----
+
+== Troubleshooting
+
+If you're seeing `cannot load such file` when running rubocop, even after installing the gems, restart the server with `rubocop --restart-server`.
diff --git a/docs/modules/ROOT/pages/usage.adoc b/docs/modules/ROOT/pages/usage.adoc
new file mode 100644
index 000000000..d0a276420
--- /dev/null
+++ b/docs/modules/ROOT/pages/usage.adoc
@@ -0,0 +1,119 @@
+= Usage
+
+You need to tell RuboCop to load the RSpec extension.
+There are three ways to do this:
+
+== RuboCop configuration file
+
+Put this into your `.rubocop.yml`:
+
+----
+plugins: rubocop-rspec
+----
+
+or, if you are using several extensions:
+
+----
+plugins:
+  - rubocop-rspec
+  - rubocop-performance
+----
+
+Now you can run `rubocop` and it will automatically load the RuboCop RSpec
+cops together with the standard cops.
+
+NOTE: The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
+=== RSpec DSL configuration
+
+In case you https://github.com/rspec/rspec-core/blob/b0d0843a285693c64cdbe0c85726db155b46047e/lib/rspec/core/configuration.rb#L1122[define aliases for RSpec DSL], i.e. examples, example groups, hooks, or include example statements, you need to configure it so those elements are properly detected by RuboCop RSpec.
+
+[source,ruby]
+----
+# spec/spec_helper.rb
+RSpec.configure do |c|
+  c.alias_example_group_to :detail, :detailed => true
+end
+
+# spec/detail_spec.rb
+RSpec.detail "a detail" do
+  it "can do some less important stuff" do
+  end
+end
+----
+
+[source,yaml]
+----
+# .rubocop.yml
+RSpec:
+  Language:
+    ExampleGroups:
+      Regular:
+        - detail
+----
+
+Some libraries extensively define RSpec DSL aliases (e.g. Pundit, Action Policy) or augment existing elements providing the same semantics (e.g. `let_it_be` from `test-prof`).
+Those libraries can provide necessary configuration, but won't necessarily do so.
+If they do, their README will mention that you have to explicitly require their configuration from your `.rubocop.yml` file.
+
+[source,yaml]
+----
+# .rubocop.yml
+
+require:
+  - rubocop-rspec
+  - test-prof
+
+# or
+
+RSpec:
+  Language:
+    Helpers:
+      - let_it_be
+----
+
+NOTE: the default merge mode is to inherit, so you won't remove any of the default settings.
+
+RuboCop RSpec's https://github.com/rubocop/rubocop-rspec/blob/a43424527c09fae2e6ddb133f4b2988f6c46bb2e/config/default.yml#L6[default configuration] is a good source of information on what can be configured.
+
+== Command line
+
+[source,bash]
+----
+$ rubocop --plugin rubocop-rspec
+----
+
+== Rake task
+
+[source,ruby]
+----
+RuboCop::RakeTask.new do |task|
+  task.plugins << 'rubocop-rspec'
+end
+----
+
+== Code Climate
+
+`rubocop-rspec` is available on Code Climate as part of the rubocop engine. https://codeclimate.com/changelog/55a433bbe30ba00852000fac[Learn More].
+
+== Inspecting files that don't end with `_spec.rb`
+
+By default, `rubocop-rspec` only inspects code within paths ending in `_spec.rb` or including `spec/`. You can override this setting in your config file by setting `Include`:
+
+[source,yaml]
+----
+# Inspect files in `test/` directory
+RSpec:
+  Include:
+    - '**/test/**/*'
+----
+
+[source,yaml]
+----
+# Inspect only files ending with `_test.rb`
+RSpec:
+  Include:
+    - '**/*_test.rb'
+----
+
+NOTE: Please keep in mind that merge mode for `Include` is set to override the default settings, so if you intend to add a path while keeping the default paths, you should include the default `Include` paths in your configuration.
diff --git a/lib/rubocop-rspec.rb b/lib/rubocop-rspec.rb
index 840b3a5a6..3de03a7ae 100644
--- a/lib/rubocop-rspec.rb
+++ b/lib/rubocop-rspec.rb
@@ -6,40 +6,46 @@
 require 'rubocop'
 
 require_relative 'rubocop/rspec'
-require_relative 'rubocop/rspec/version'
-require_relative 'rubocop/rspec/inject'
+require_relative 'rubocop/rspec/language'
 require_relative 'rubocop/rspec/node'
-require_relative 'rubocop/rspec/top_level_describe'
+require_relative 'rubocop/rspec/plugin'
+require_relative 'rubocop/rspec/version'
 require_relative 'rubocop/rspec/wording'
-require_relative 'rubocop/rspec/language'
-require_relative 'rubocop/rspec/language/node_pattern'
+
+require_relative 'rubocop/cop/rspec/mixin/file_help'
+require_relative 'rubocop/cop/rspec/mixin/final_end_location'
+require_relative 'rubocop/cop/rspec/mixin/inside_example_group'
+require_relative 'rubocop/cop/rspec/mixin/location_help'
+require_relative 'rubocop/cop/rspec/mixin/metadata'
+require_relative 'rubocop/cop/rspec/mixin/namespace'
+require_relative 'rubocop/cop/rspec/mixin/skip_or_pending'
+require_relative 'rubocop/cop/rspec/mixin/top_level_group'
+require_relative 'rubocop/cop/rspec/mixin/variable'
+
+# Dependent on `RuboCop::Cop::RSpec::FinalEndLocation`.
+require_relative 'rubocop/cop/rspec/mixin/comments_help'
+require_relative 'rubocop/cop/rspec/mixin/empty_line_separation'
+
+require_relative 'rubocop/cop/rspec/base'
+require_relative 'rubocop/rspec/align_let_brace'
 require_relative 'rubocop/rspec/concept'
-require_relative 'rubocop/rspec/example_group'
+require_relative 'rubocop/rspec/corrector/move_node'
 require_relative 'rubocop/rspec/example'
+require_relative 'rubocop/rspec/example_group'
 require_relative 'rubocop/rspec/hook'
-require_relative 'rubocop/cop/rspec/cop'
-require_relative 'rubocop/rspec/align_let_brace'
-require_relative 'rubocop/rspec/factory_bot'
-require_relative 'rubocop/rspec/final_end_location'
-require_relative 'rubocop/rspec/blank_line_separation'
-
-RuboCop::RSpec::Inject.defaults!
 
 require_relative 'rubocop/cop/rspec_cops'
 
-# We have to register our autocorrect incompatibilies in RuboCop's cops as well
-# so we do not hit infinite loops
-
-module RuboCop
-  module Cop
-    module Layout
-      class ExtraSpacing # rubocop:disable Style/Documentation
-        def self.autocorrect_incompatible_with
-          [RSpec::AlignLeftLetBrace, RSpec::AlignRightLetBrace]
-        end
-      end
+# We have to register our autocorrect incompatibilities in RuboCop's cops
+# as well so we do not hit infinite loops
+
+RuboCop::Cop::Layout::ExtraSpacing.singleton_class.prepend(
+  Module.new do
+    def autocorrect_incompatible_with
+      super.push(RuboCop::Cop::RSpec::AlignLeftLetBrace)
+      .push(RuboCop::Cop::RSpec::AlignRightLetBrace)
     end
   end
-end
+)
 
 RuboCop::AST::Node.include(RuboCop::RSpec::Node)
diff --git a/lib/rubocop/cop/rspec/align_left_let_brace.rb b/lib/rubocop/cop/rspec/align_left_let_brace.rb
index 08669f3aa..990222a68 100644
--- a/lib/rubocop/cop/rspec/align_left_let_brace.rb
+++ b/lib/rubocop/cop/rspec/align_left_let_brace.rb
@@ -6,46 +6,42 @@ module RSpec
       # Checks that left braces for adjacent single line lets are aligned.
       #
       # @example
+      #   # bad
+      #   let(:foobar) { blahblah }
+      #   let(:baz) { bar }
+      #   let(:a) { b }
       #
-      #     # bad
-      #     let(:foobar) { blahblah }
-      #     let(:baz) { bar }
-      #     let(:a) { b }
+      #   # good
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar }
+      #   let(:a)      { b }
       #
-      #     # good
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar }
-      #     let(:a)      { b }
-      #
-      class AlignLeftLetBrace < Cop
+      class AlignLeftLetBrace < Base
+        extend AutoCorrector
+
         MSG = 'Align left let brace'
 
         def self.autocorrect_incompatible_with
           [Layout::ExtraSpacing]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
+          super
           return if processed_source.blank?
 
           token_aligner.offending_tokens.each do |let|
-            add_offense(let, location: :begin)
-          end
-        end
-
-        def autocorrect(let)
-          lambda do |corrector|
-            corrector.insert_before(
-              let.loc.begin,
-              token_aligner.indent_for(let)
-            )
+            add_offense(let.loc.begin) do |corrector|
+              corrector.insert_before(
+                let.loc.begin, token_aligner.indent_for(let)
+              )
+            end
           end
         end
 
         private
 
         def token_aligner
-          @token_aligner ||=
-            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
+          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/align_right_let_brace.rb b/lib/rubocop/cop/rspec/align_right_let_brace.rb
index 0526a09ac..cd33e6d8e 100644
--- a/lib/rubocop/cop/rspec/align_right_let_brace.rb
+++ b/lib/rubocop/cop/rspec/align_right_let_brace.rb
@@ -6,46 +6,42 @@ module RSpec
       # Checks that right braces for adjacent single line lets are aligned.
       #
       # @example
+      #   # bad
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar }
+      #   let(:a)      { b }
       #
-      #     # bad
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar }
-      #     let(:a)      { b }
+      #   # good
+      #   let(:foobar) { blahblah }
+      #   let(:baz)    { bar      }
+      #   let(:a)      { b        }
       #
-      #     # good
-      #     let(:foobar) { blahblah }
-      #     let(:baz)    { bar      }
-      #     let(:a)      { b        }
-      #
-      class AlignRightLetBrace < Cop
+      class AlignRightLetBrace < Base
+        extend AutoCorrector
+
         MSG = 'Align right let brace'
 
         def self.autocorrect_incompatible_with
           [Layout::ExtraSpacing]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
+          super
           return if processed_source.blank?
 
           token_aligner.offending_tokens.each do |let|
-            add_offense(let, location: :end)
-          end
-        end
-
-        def autocorrect(let)
-          lambda do |corrector|
-            corrector.insert_before(
-              let.loc.end,
-              token_aligner.indent_for(let)
-            )
+            add_offense(let.loc.end) do |corrector|
+              corrector.insert_before(
+                let.loc.end, token_aligner.indent_for(let)
+              )
+            end
           end
         end
 
         private
 
         def token_aligner
-          @token_aligner ||=
-            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
+          RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/any_instance.rb b/lib/rubocop/cop/rspec/any_instance.rb
index 08c92a867..6c0e5bb8e 100644
--- a/lib/rubocop/cop/rspec/any_instance.rb
+++ b/lib/rubocop/cop/rspec/any_instance.rb
@@ -22,20 +22,17 @@ module RSpec
       #       allow(my_instance).to receive(:foo)
       #     end
       #   end
-      class AnyInstance < Cop
+      #
+      class AnyInstance < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
-
-        def_node_matcher :disallowed_stub, <<-PATTERN
-          (send _ ${:any_instance :allow_any_instance_of :expect_any_instance_of} ...)
-        PATTERN
+        RESTRICT_ON_SEND = %i[
+          any_instance
+          allow_any_instance_of
+          expect_any_instance_of
+        ].freeze
 
         def on_send(node)
-          disallowed_stub(node) do |method|
-            add_offense(
-              node,
-              message: format(MSG, method: method)
-            )
-          end
+          add_offense(node, message: format(MSG, method: node.method_name))
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/around_block.rb b/lib/rubocop/cop/rspec/around_block.rb
index 0dc006364..c10d8f183 100644
--- a/lib/rubocop/cop/rspec/around_block.rb
+++ b/lib/rubocop/cop/rspec/around_block.rb
@@ -25,21 +25,29 @@ module RSpec
       #     some_method
       #     test.run
       #   end
-      class AroundBlock < Cop
+      #
+      class AroundBlock < Base
         MSG_NO_ARG     = 'Test object should be passed to around block.'
-        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` '\
+        MSG_UNUSED_ARG = 'You should call `%<arg>s.call` ' \
                          'or `%<arg>s.run`.'
 
-        def_node_matcher :hook, <<-PATTERN
-          (block {(send nil? :around) (send nil? :around sym)} (args $...) ...)
+        # @!method hook_block(node)
+        def_node_matcher :hook_block, <<~PATTERN
+          (block (send nil? :around sym ?) (args $...) ...)
+        PATTERN
+
+        # @!method hook_numblock(node)
+        def_node_matcher :hook_numblock, <<~PATTERN
+          (numblock (send nil? :around sym ?) ...)
         PATTERN
 
-        def_node_search :find_arg_usage, <<-PATTERN
+        # @!method find_arg_usage(node)
+        def_node_search :find_arg_usage, <<~PATTERN
           {(send $... {:call :run}) (send _ _ $...) (yield $...) (block-pass $...)}
         PATTERN
 
         def on_block(node)
-          hook(node) do |(example_proxy)|
+          hook_block(node) do |(example_proxy)|
             if example_proxy.nil?
               add_no_arg_offense(node)
             else
@@ -48,6 +56,12 @@ def on_block(node)
           end
         end
 
+        def on_numblock(node)
+          hook_numblock(node) do
+            check_for_numblock(node)
+          end
+        end
+
         private
 
         def add_no_arg_offense(node)
@@ -55,15 +69,24 @@ def add_no_arg_offense(node)
         end
 
         def check_for_unused_proxy(block, proxy)
-          name, = *proxy
-
           find_arg_usage(block) do |usage|
-            return if usage.include?(s(:lvar, name))
+            return if usage.include?(s(:lvar, proxy.name))
           end
 
           add_offense(
             proxy,
-            message: format(MSG_UNUSED_ARG, arg: name)
+            message: format(MSG_UNUSED_ARG, arg: proxy.name)
+          )
+        end
+
+        def check_for_numblock(block)
+          find_arg_usage(block) do |usage|
+            return if usage.include?(s(:lvar, :_1))
+          end
+
+          add_offense(
+            block.children.last,
+            message: format(MSG_UNUSED_ARG, arg: :_1)
           )
         end
       end
diff --git a/lib/rubocop/cop/rspec/base.rb b/lib/rubocop/cop/rspec/base.rb
new file mode 100644
index 000000000..0152f108f
--- /dev/null
+++ b/lib/rubocop/cop/rspec/base.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # @abstract parent class to RSpec cops
+      class Base < ::RuboCop::Cop::Base
+        include RuboCop::RSpec::Language
+
+        exclude_from_registry
+
+        # Invoke the original inherited hook so our cops are recognized
+        def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
+          RuboCop::Cop::Base.inherited(subclass)
+        end
+
+        # Set the config for dynamic DSL configuration-aware helpers
+        # that have no other means of accessing the configuration.
+        def on_new_investigation
+          super
+          RuboCop::RSpec::Language.config = config['RSpec']['Language']
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/be.rb b/lib/rubocop/cop/rspec/be.rb
index 503648e12..6536389dc 100644
--- a/lib/rubocop/cop/rspec/be.rb
+++ b/lib/rubocop/cop/rspec/be.rb
@@ -10,7 +10,6 @@ module RSpec
       # cases it's better to specify what exactly is the expected value.
       #
       # @example
-      #
       #   # bad
       #   expect(foo).to be
       #
@@ -19,16 +18,19 @@ module RSpec
       #   expect(foo).to be 1.0
       #   expect(foo).to be(true)
       #
-      class Be < Cop
-        MSG = 'Don\'t use `be` without an argument.'
+      class Be < Base
+        MSG = "Don't use `be` without an argument."
+
+        RESTRICT_ON_SEND = Runners.all
 
-        def_node_matcher :be_without_args, <<-PATTERN
-          (send _ #{Runners::ALL.node_pattern_union} $(send nil? :be))
+        # @!method be_without_args(node)
+        def_node_matcher :be_without_args, <<~PATTERN
+          (send _ #Runners.all $(send nil? :be))
         PATTERN
 
         def on_send(node)
           be_without_args(node) do |matcher|
-            add_offense(matcher, location: :selector)
+            add_offense(matcher.loc.selector)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/be_empty.rb b/lib/rubocop/cop/rspec/be_empty.rb
new file mode 100644
index 000000000..fbd79fdb0
--- /dev/null
+++ b/lib/rubocop/cop/rspec/be_empty.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer using `be_empty` when checking for an empty array.
+      #
+      # @example
+      #   # bad
+      #   expect(array).to contain_exactly
+      #   expect(array).to match_array([])
+      #
+      #   # good
+      #   expect(array).to be_empty
+      #
+      class BeEmpty < Base
+        extend AutoCorrector
+
+        MSG = 'Use `be_empty` matchers for checking an empty array.'
+        RESTRICT_ON_SEND = %i[contain_exactly match_array].freeze
+
+        # @!method expect_array_matcher?(node)
+        def_node_matcher :expect_array_matcher?, <<~PATTERN
+          (send
+            (send nil? :expect _)
+            #Runners.all
+            ${
+              (send nil? :match_array (array))
+              (send nil? :contain_exactly)
+            }
+            _?
+          )
+        PATTERN
+
+        def on_send(node)
+          expect_array_matcher?(node.parent) do |expect|
+            add_offense(expect) do |corrector|
+              corrector.replace(expect, 'be_empty')
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/be_eq.rb b/lib/rubocop/cop/rspec/be_eq.rb
new file mode 100644
index 000000000..dfdcd7c5a
--- /dev/null
+++ b/lib/rubocop/cop/rspec/be_eq.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for expectations where `be(...)` can replace `eq(...)`.
+      #
+      # The `be` matcher compares by identity while the `eq` matcher compares
+      # using `==`. Booleans and nil can be compared by identity and therefore
+      # the `be` matcher is preferable as it is a more strict test.
+      #
+      # @safety
+      #   This cop is unsafe because it changes how values are compared.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to eq(true)
+      #   expect(foo).to eq(false)
+      #   expect(foo).to eq(nil)
+      #
+      #   # good
+      #   expect(foo).to be(true)
+      #   expect(foo).to be(false)
+      #   expect(foo).to be(nil)
+      #
+      class BeEq < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `be` over `eq`.'
+        RESTRICT_ON_SEND = %i[eq].freeze
+
+        # @!method eq_type_with_identity?(node)
+        def_node_matcher :eq_type_with_identity?, <<~PATTERN
+          (send nil? :eq {boolean nil})
+        PATTERN
+
+        def on_send(node)
+          return unless eq_type_with_identity?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'be')
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/be_eql.rb b/lib/rubocop/cop/rspec/be_eql.rb
index 0721c8c53..f49a69231 100644
--- a/lib/rubocop/cop/rspec/be_eql.rb
+++ b/lib/rubocop/cop/rspec/be_eql.rb
@@ -10,8 +10,10 @@ module RSpec
       # can be compared by identity and therefore the `be` matcher is
       # preferable as it is a more strict test.
       #
-      # @example
+      # @safety
+      #   This cop is unsafe because it changes how values are compared.
       #
+      # @example
       #   # bad
       #   expect(foo).to eql(1)
       #   expect(foo).to eql(1.0)
@@ -35,22 +37,24 @@ module RSpec
       # necessarily the same type as `b` since the `#==` operator can
       # coerce objects for comparison.
       #
-      class BeEql < Cop
+      class BeEql < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `be` over `eql`.'
+        RESTRICT_ON_SEND = %i[to].freeze
 
-        def_node_matcher :eql_type_with_identity, <<-PATTERN
-          (send _ :to $(send nil? :eql {true false int float sym nil_type?}))
+        # @!method eql_type_with_identity(node)
+        def_node_matcher :eql_type_with_identity, <<~PATTERN
+          (send _ :to $(send nil? :eql {boolean int float sym nil}))
         PATTERN
 
         def on_send(node)
           eql_type_with_identity(node) do |eql|
-            add_offense(eql, location: :selector)
+            add_offense(eql.loc.selector) do |corrector|
+              corrector.replace(eql.loc.selector, 'be')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'be') }
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/be_nil.rb b/lib/rubocop/cop/rspec/be_nil.rb
new file mode 100644
index 000000000..1a755ba64
--- /dev/null
+++ b/lib/rubocop/cop/rspec/be_nil.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensures a consistent style is used when matching `nil`.
+      #
+      # You can either use the more specific `be_nil` matcher, or the more
+      # generic `be` matcher with a `nil` argument.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: be_nil` (default)
+      #   # bad
+      #   expect(foo).to be(nil)
+      #
+      #   # good
+      #   expect(foo).to be_nil
+      #
+      # @example `EnforcedStyle: be`
+      #   # bad
+      #   expect(foo).to be_nil
+      #
+      #   # good
+      #   expect(foo).to be(nil)
+      #
+      class BeNil < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        BE_MSG = 'Prefer `be(nil)` over `be_nil`.'
+        BE_NIL_MSG = 'Prefer `be_nil` over `be(nil)`.'
+        RESTRICT_ON_SEND = %i[be be_nil].freeze
+
+        # @!method be_nil_matcher?(node)
+        def_node_matcher :be_nil_matcher?, <<~PATTERN
+          (send nil? :be_nil)
+        PATTERN
+
+        # @!method nil_value_expectation?(node)
+        def_node_matcher :nil_value_expectation?, <<~PATTERN
+          (send nil? :be nil)
+        PATTERN
+
+        def on_send(node)
+          case style
+          when :be
+            check_be_style(node)
+          when :be_nil
+            check_be_nil_style(node)
+          else
+            # :nocov:
+            :noop
+            # :nocov:
+          end
+        end
+
+        private
+
+        def check_be_style(node)
+          return unless be_nil_matcher?(node)
+
+          add_offense(node, message: BE_MSG) do |corrector|
+            corrector.replace(node, 'be(nil)')
+          end
+        end
+
+        def check_be_nil_style(node)
+          return unless nil_value_expectation?(node)
+
+          add_offense(node, message: BE_NIL_MSG) do |corrector|
+            corrector.replace(node, 'be_nil')
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/before_after_all.rb b/lib/rubocop/cop/rspec/before_after_all.rb
index e4809ff93..53f7b9ae6 100644
--- a/lib/rubocop/cop/rspec/before_after_all.rb
+++ b/lib/rubocop/cop/rspec/before_after_all.rb
@@ -3,34 +3,32 @@
 module RuboCop
   module Cop
     module RSpec
-      # Check that before/after(:all) isn't being used.
+      # Check that before/after(:all/:context) isn't being used.
       #
       # @example
-      #   # bad
-      #   #
-      #   # Faster but risk of state leaking between examples
-      #   #
+      #   # bad - Faster but risk of state leaking between examples
       #   describe MyClass do
       #     before(:all) { Widget.create }
-      #     after(:all) { Widget.delete_all }
+      #     after(:context) { Widget.delete_all }
       #   end
       #
-      #   # good
-      #   #
-      #   # Slower but examples are properly isolated
-      #   #
+      #   # good - Slower but examples are properly isolated
       #   describe MyClass do
       #     before(:each) { Widget.create }
       #     after(:each) { Widget.delete_all }
       #   end
-      class BeforeAfterAll < Cop
-        MSG = 'Beware of using `%<hook>s` as it may cause state to leak '\
-              'between tests. If you are using `rspec-rails`, and '\
-              '`use_transactional_fixtures` is enabled, then records created '\
+      #
+      class BeforeAfterAll < Base
+        MSG = 'Beware of using `%<hook>s` as it may cause state to leak ' \
+              'between tests. If you are using `rspec-rails`, and ' \
+              '`use_transactional_fixtures` is enabled, then records created ' \
               'in `%<hook>s` are not automatically rolled back.'
 
-        def_node_matcher :before_or_after_all, <<-PATTERN
-          $(send _ {:before :after} (sym {:all :context}))
+        RESTRICT_ON_SEND = Set[:before, :after].freeze
+
+        # @!method before_or_after_all(node)
+        def_node_matcher :before_or_after_all, <<~PATTERN
+          $(send _ RESTRICT_ON_SEND (sym {:all :context}))
         PATTERN
 
         def on_send(node)
diff --git a/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb b/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb
deleted file mode 100644
index c69303161..000000000
--- a/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb
+++ /dev/null
@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks that no expectations are set on Capybara's `current_path`.
-        #
-        # The `have_current_path` matcher (https://www.rubydoc.info/github/
-        # teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-
-        # instance_method) should be used on `page` to set expectations on
-        # Capybara's current path, since it uses Capybara's waiting
-        # functionality (https://github.com/teamcapybara/capybara/blob/master/
-        # README.md#asynchronous-javascript-ajax-and-friends) which ensures that
-        # preceding actions (like `click_link`) have completed.
-        #
-        # @example
-        #   # bad
-        #   expect(current_path).to eq('/callback')
-        #   expect(page.current_path).to match(/widgets/)
-        #
-        #   # good
-        #   expect(page).to have_current_path("/callback")
-        #   expect(page).to have_current_path(/widgets/)
-        #
-        class CurrentPathExpectation < Cop
-          MSG = 'Do not set an RSpec expectation on `current_path` in ' \
-                'Capybara feature specs - instead, use the ' \
-                '`have_current_path` matcher on `page`'
-
-          def_node_matcher :expectation_set_on_current_path, <<-PATTERN
-            (send nil? :expect (send {(send nil? :page) nil?} :current_path))
-          PATTERN
-
-          # Supported matchers: eq(...) / match(/regexp/) / match('regexp')
-          def_node_matcher :as_is_matcher, <<-PATTERN
-            (send
-              #expectation_set_on_current_path $#{Runners::ALL.node_pattern_union}
-              ${(send nil? :eq ...) (send nil? :match (regexp ...))})
-          PATTERN
-
-          def_node_matcher :regexp_str_matcher, <<-PATTERN
-            (send
-              #expectation_set_on_current_path $#{Runners::ALL.node_pattern_union}
-              $(send nil? :match (str $_)))
-          PATTERN
-
-          def on_send(node)
-            expectation_set_on_current_path(node) do
-              add_offense(node, location: :selector)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              return unless node.chained?
-
-              as_is_matcher(node.parent) do |to_sym, matcher_node|
-                rewrite_expectation(corrector, node, to_sym, matcher_node)
-              end
-
-              regexp_str_matcher(node.parent) do |to_sym, matcher_node, regexp|
-                rewrite_expectation(corrector, node, to_sym, matcher_node)
-                convert_regexp_str_to_literal(corrector, matcher_node, regexp)
-              end
-            end
-          end
-
-          private
-
-          def rewrite_expectation(corrector, node, to_symbol, matcher_node)
-            current_path_node = node.first_argument
-            corrector.replace(current_path_node.loc.expression, 'page')
-            corrector.replace(node.parent.loc.selector, 'to')
-            matcher_method = if to_symbol == :to
-                               'have_current_path'
-                             else
-                               'have_no_current_path'
-                             end
-            corrector.replace(matcher_node.loc.selector, matcher_method)
-            add_ignore_query_options(corrector, node)
-          end
-
-          def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str)
-            str_node = matcher_node.first_argument
-            regexp_expr = Regexp.new(regexp_str).inspect
-            corrector.replace(str_node.loc.expression, regexp_expr)
-          end
-
-          # `have_current_path` with no options will include the querystring
-          # while `page.current_path` does not.
-          # This ensures the option `ignore_query: true` is added
-          # except when the expectation is a regexp or string
-          def add_ignore_query_options(corrector, node)
-            expectation_node = node.parent.last_argument
-            expectation_last_child = expectation_node.children.last
-            return if %i[regexp str].include?(expectation_last_child.type)
-
-            corrector.insert_after(
-              expectation_last_child.loc.expression,
-              ', ignore_query: true'
-            )
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/capybara/feature_methods.rb b/lib/rubocop/cop/rspec/capybara/feature_methods.rb
deleted file mode 100644
index f6681fe28..000000000
--- a/lib/rubocop/cop/rspec/capybara/feature_methods.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Capybara
-        # Checks for consistent method usage in feature specs.
-        #
-        # By default, the cop disables all Capybara-specific methods that have
-        # the same native RSpec method (e.g. are just aliases). Some teams
-        # however may prefer using some of the Capybara methods (like `feature`)
-        # to make it obvious that the test uses Capybara, while still disable
-        # the rest of the methods, like `given` (alias for `let`), `background`
-        # (alias for `before`), etc. You can configure which of the methods to
-        # be enabled by using the EnabledMethods configuration option.
-        #
-        # @example
-        #   # bad
-        #   feature 'User logs in' do
-        #     given(:user) { User.new }
-        #
-        #     background do
-        #       visit new_session_path
-        #     end
-        #
-        #     scenario 'with OAuth' do
-        #       # ...
-        #     end
-        #   end
-        #
-        #   # good
-        #   describe 'User logs in' do
-        #     let(:user) { User.new }
-        #
-        #     before do
-        #       visit new_session_path
-        #     end
-        #
-        #     it 'with OAuth' do
-        #       # ...
-        #     end
-        #   end
-        class FeatureMethods < Cop
-          MSG = 'Use `%<replacement>s` instead of `%<method>s`.'
-
-          # https://git.io/v7Kwr
-          MAP = {
-            background: :before,
-            scenario:   :it,
-            xscenario:  :xit,
-            given:      :let,
-            given!:     :let!,
-            feature:    :describe
-          }.freeze
-
-          def_node_matcher :spec?, <<-PATTERN
-            (block
-              (send #{RSPEC} {:describe :feature} ...)
-            ...)
-          PATTERN
-
-          def_node_matcher :feature_method, <<-PATTERN
-            (block
-              $(send #{RSPEC} ${#{MAP.keys.map(&:inspect).join(' ')}} ...)
-            ...)
-          PATTERN
-
-          def on_block(node)
-            return unless inside_spec?(node)
-
-            feature_method(node) do |send_node, match|
-              next if enabled?(match)
-
-              add_offense(
-                send_node,
-                location: :selector,
-                message: format(MSG, method: match, replacement: MAP[match])
-              )
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, MAP[node.method_name].to_s)
-            end
-          end
-
-          private
-
-          def inside_spec?(node)
-            return spec?(node) if root_node?(node)
-
-            root = node.ancestors.find { |parent| root_node?(parent) }
-            spec?(root)
-          end
-
-          def root_node?(node)
-            node.parent.nil? || root_with_siblings?(node.parent)
-          end
-
-          def root_with_siblings?(node)
-            node.begin_type? && node.parent.nil?
-          end
-
-          def enabled?(method_name)
-            enabled_methods.include?(method_name)
-          end
-
-          def enabled_methods
-            cop_config
-              .fetch('EnabledMethods', [])
-              .map(&:to_sym)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/change_by_zero.rb b/lib/rubocop/cop/rspec/change_by_zero.rb
new file mode 100644
index 000000000..64c5df4b2
--- /dev/null
+++ b/lib/rubocop/cop/rspec/change_by_zero.rb
@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer negated matchers over `to change.by(0)`.
+      #
+      # In the case of composite expectations, cop suggest using the
+      # negation matchers of `RSpec::Matchers#change`.
+      #
+      # By default the cop does not support autocorrect of
+      # compound expectations, but if you set the
+      # negated matcher for `change`, e.g. `not_change` with
+      # the `NegatedMatcher` option, the cop will perform the autocorrection.
+      #
+      # @example NegatedMatcher: ~ (default)
+      #   # bad
+      #   expect { run }.to change(Foo, :bar).by(0)
+      #   expect { run }.to change { Foo.bar }.by(0)
+      #
+      #   # bad - compound expectations (does not support autocorrection)
+      #   expect { run }
+      #     .to change(Foo, :bar).by(0)
+      #     .and change(Foo, :baz).by(0)
+      #   expect { run }
+      #     .to change { Foo.bar }.by(0)
+      #     .and change { Foo.baz }.by(0)
+      #
+      #   # good
+      #   expect { run }.not_to change(Foo, :bar)
+      #   expect { run }.not_to change { Foo.bar }
+      #
+      #   # good - compound expectations
+      #   define_negated_matcher :not_change, :change
+      #   expect { run }
+      #     .to not_change(Foo, :bar)
+      #     .and not_change(Foo, :baz)
+      #   expect { run }
+      #     .to not_change { Foo.bar }
+      #     .and not_change { Foo.baz }
+      #
+      # @example NegatedMatcher: not_change
+      #   # bad (support autocorrection to good case)
+      #   expect { run }
+      #     .to change(Foo, :bar).by(0)
+      #     .and change(Foo, :baz).by(0)
+      #   expect { run }
+      #     .to change { Foo.bar }.by(0)
+      #     .and change { Foo.baz }.by(0)
+      #
+      #   # good
+      #   define_negated_matcher :not_change, :change
+      #   expect { run }
+      #     .to not_change(Foo, :bar)
+      #     .and not_change(Foo, :baz)
+      #   expect { run }
+      #     .to not_change { Foo.bar }
+      #     .and not_change { Foo.baz }
+      #
+      class ChangeByZero < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Prefer `not_to change` over `to %<method>s.by(0)`.'
+        MSG_COMPOUND = 'Prefer %<preferred>s with compound expectations ' \
+                       'over `%<method>s.by(0)`.'
+        CHANGE_METHODS = Set[:change, :a_block_changing, :changing].freeze
+        RESTRICT_ON_SEND = CHANGE_METHODS.freeze
+
+        # @!method expect_change_with_arguments(node)
+        def_node_matcher :expect_change_with_arguments, <<~PATTERN
+          (send
+            $(send nil? CHANGE_METHODS ...) :by
+            (int 0))
+        PATTERN
+
+        # @!method expect_change_with_block(node)
+        def_node_matcher :expect_change_with_block, <<~PATTERN
+          (send
+            (block
+              $(send nil? CHANGE_METHODS)
+              (args)
+              (send (...) _)) :by
+            (int 0))
+        PATTERN
+
+        # @!method change_nodes(node)
+        def_node_search :change_nodes, <<~PATTERN
+          $(send nil? CHANGE_METHODS ...)
+        PATTERN
+
+        def on_send(node)
+          expect_change_with_arguments(node.parent) do |change|
+            register_offense(node.parent, change)
+          end
+
+          expect_change_with_block(node.parent.parent) do |change|
+            register_offense(node.parent.parent, change)
+          end
+        end
+
+        private
+
+        def register_offense(node, change_node)
+          return unless node.parent.send_type?
+
+          if compound_expectations?(node)
+            add_offense(node,
+                        message: message_compound(change_node)) do |corrector|
+              autocorrect_compound(corrector, node)
+            end
+          else
+            add_offense(node,
+                        message: message(change_node)) do |corrector|
+              autocorrect(corrector, node, change_node)
+            end
+          end
+        end
+
+        def compound_expectations?(node)
+          %i[and or & |].include?(node.parent.method_name)
+        end
+
+        def message(change_node)
+          format(MSG, method: change_node.method_name)
+        end
+
+        def message_compound(change_node)
+          format(MSG_COMPOUND, preferred: preferred_method,
+                               method: change_node.method_name)
+        end
+
+        def autocorrect(corrector, node, change_node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          corrector.replace(change_node.loc.selector, 'change')
+          range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+          corrector.remove(range)
+        end
+
+        def autocorrect_compound(corrector, node)
+          return unless negated_matcher
+
+          change_nodes(node) do |change_node|
+            corrector.replace(change_node.loc.selector, negated_matcher)
+            insert_operator(corrector, node, change_node)
+            remove_by_zero(corrector, node, change_node)
+          end
+        end
+
+        def insert_operator(corrector, node, change_node)
+          operator = node.right_siblings.first
+          return unless %i[& |].include?(operator)
+
+          corrector.insert_after(
+            replace_node(node, change_node), " #{operator}"
+          )
+        end
+
+        def replace_node(node, change_node)
+          expect_change_with_arguments(node) ? change_node : change_node.parent
+        end
+
+        def remove_by_zero(corrector, node, change_node)
+          range = node.loc.dot.with(end_pos: node.source_range.end_pos)
+          if change_node.loc.line == range.line
+            corrector.remove(range)
+          else
+            corrector.remove(
+              range_by_whole_lines(range, include_final_newline: true)
+            )
+          end
+        end
+
+        def negated_matcher
+          cop_config['NegatedMatcher']
+        end
+
+        def preferred_method
+          negated_matcher ? "`#{negated_matcher}`" : 'negated matchers'
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/class_check.rb b/lib/rubocop/cop/rspec/class_check.rb
new file mode 100644
index 000000000..5e426d5d2
--- /dev/null
+++ b/lib/rubocop/cop/rspec/class_check.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Enforces consistent use of `be_a` or `be_kind_of`.
+      #
+      # @example EnforcedStyle: be_a (default)
+      #   # bad
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      #   # good
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      # @example EnforcedStyle: be_kind_of
+      #   # bad
+      #   expect(object).to be_a(String)
+      #   expect(object).to be_an(String)
+      #
+      #   # good
+      #   expect(object).to be_kind_of(String)
+      #   expect(object).to be_a_kind_of(String)
+      #
+      class ClassCheck < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<preferred>s` over `%<current>s`.'
+
+        METHOD_NAMES_FOR_BE_A = ::Set[
+          :be_a,
+          :be_an
+        ].freeze
+
+        METHOD_NAMES_FOR_KIND_OF = ::Set[
+          :be_a_kind_of,
+          :be_kind_of
+        ].freeze
+
+        PREFERRED_METHOD_NAME_BY_STYLE = {
+          be_a: :be_a,
+          be_kind_of: :be_kind_of
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[
+          be_a
+          be_a_kind_of
+          be_an
+          be_kind_of
+        ].freeze
+
+        def on_send(node)
+          return unless offending?(node)
+
+          add_offense(
+            node.loc.selector,
+            message: format_message(node)
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.loc.selector, preferred_method_name)
+        end
+
+        def format_message(node)
+          format(
+            MSG,
+            current: node.method_name,
+            preferred: preferred_method_name
+          )
+        end
+
+        def offending?(node)
+          !node.receiver && !preferred_method_name?(node.method_name)
+        end
+
+        def preferred_method_name?(method_name)
+          preferred_method_names.include?(method_name)
+        end
+
+        def preferred_method_name
+          PREFERRED_METHOD_NAME_BY_STYLE[style]
+        end
+
+        def preferred_method_names
+          if style == :be_a
+            METHOD_NAMES_FOR_BE_A
+          else
+            METHOD_NAMES_FOR_KIND_OF
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/contain_exactly.rb b/lib/rubocop/cop/rspec/contain_exactly.rb
new file mode 100644
index 000000000..bdb44ed8d
--- /dev/null
+++ b/lib/rubocop/cop/rspec/contain_exactly.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks where `contain_exactly` is used.
+      #
+      # This cop checks for the following:
+      #
+      # - Prefer `match_array` when matching array values.
+      # - Prefer `be_empty` when using `contain_exactly` with no arguments.
+      #
+      # @example
+      #   # bad
+      #   it { is_expected.to contain_exactly(*array1, *array2) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(array1 + array2) }
+      #
+      #   # good
+      #   it { is_expected.to contain_exactly(content, *array) }
+      #
+      class ContainExactly < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `match_array` when matching array values.'
+        RESTRICT_ON_SEND = %i[contain_exactly].freeze
+
+        def on_send(node)
+          return if node.arguments.empty?
+
+          check_populated_collection(node)
+        end
+
+        private
+
+        def check_populated_collection(node)
+          return unless node.each_child_node.all?(&:splat_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect_for_populated_array(node, corrector)
+          end
+        end
+
+        def autocorrect_for_populated_array(node, corrector)
+          arrays = node.arguments.map do |splat_node|
+            splat_node.children.first
+          end
+          corrector.replace(
+            node,
+            "match_array(#{arrays.map(&:source).join(' + ')})"
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/context_method.rb b/lib/rubocop/cop/rspec/context_method.rb
index 23061ad3f..1e28e8b18 100644
--- a/lib/rubocop/cop/rspec/context_method.rb
+++ b/lib/rubocop/cop/rspec/context_method.rb
@@ -23,22 +23,26 @@ module RSpec
       #   describe '.foo_bar' do
       #     # ...
       #   end
-      class ContextMethod < Cop
+      #
+      class ContextMethod < Base
+        extend AutoCorrector
+
         MSG = 'Use `describe` for testing methods.'
 
-        def_node_matcher :context_method, <<-PATTERN
-          (block (send #{RSPEC} :context $(str #method_name?) ...) ...)
+        # @!method context_method(node)
+        def_node_matcher :context_method, <<~PATTERN
+          (block
+            (send #rspec? :context
+              ${(str #method_name?) (dstr (str #method_name?) ...)}
+            ...)
+          ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           context_method(node) do |context|
-            add_offense(context)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.selector, 'describe')
+            add_offense(context) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'describe')
+            end
           end
         end
 
diff --git a/lib/rubocop/cop/rspec/context_wording.rb b/lib/rubocop/cop/rspec/context_wording.rb
index 285cf263a..96c40a76e 100644
--- a/lib/rubocop/cop/rspec/context_wording.rb
+++ b/lib/rubocop/cop/rspec/context_wording.rb
@@ -8,12 +8,14 @@ module RSpec
       # The default list of prefixes is minimal. Users are encouraged to tailor
       # the configuration to meet project needs. Other acceptable prefixes may
       # include `if`, `unless`, `for`, `before`, `after`, or `during`.
+      # They may consist of multiple words if desired.
       #
-      # @see https://rspec.rubystyle.guide/#context-descriptions
       # @see http://www.betterspecs.org/#contexts
       #
-      # @example `Prefixes` configuration
+      # If both `Prefixes` and `AllowedPatterns` are empty, this cop will always
+      # report an offense. So you need to set at least one of them.
       #
+      # @example `Prefixes` configuration
       #   # .rubocop.yml
       #   # RSpec/ContextWording:
       #   #   Prefixes:
@@ -34,36 +36,91 @@ module RSpec
       #   context 'when the display name is not present' do
       #     # ...
       #   end
-      class ContextWording < Cop
-        MSG = 'Start context description with %<prefixes>s.'
+      #
+      # This cop can be customized allowed context description pattern
+      # with `AllowedPatterns`. By default, there are no checking by pattern.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/ContextWording:
+      #   #   AllowedPatterns:
+      #   #     - とき$
+      #
+      # @example
+      #   # bad
+      #   context '条件を満たす' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context '条件を満たすとき' do
+      #     # ...
+      #   end
+      #
+      class ContextWording < Base
+        include AllowedPattern
+
+        MSG_MATCH = 'Context description should match %<patterns>s.'
+        MSG_ALWAYS = 'Current settings will always report an offense. Please ' \
+                     'add allowed words to `Prefixes` or `AllowedPatterns`.'
 
-        def_node_matcher :context_wording, <<-PATTERN
-          (block (send #{RSPEC} { :context :shared_context } $(str #bad_prefix?) ...) ...)
+        # @!method context_wording(node)
+        def_node_matcher :context_wording, <<~PATTERN
+          (block (send #rspec? { :context :shared_context } $({str dstr xstr} ...) ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           context_wording(node) do |context|
-            add_offense(context,
-                        message: format(MSG, prefixes: joined_prefixes))
+            unless matches_allowed_pattern?(description(context))
+              add_offense(context, message: message)
+            end
           end
         end
 
         private
 
-        def bad_prefix?(description)
-          !prefixes.include?(description.split.first)
+        def allowed_patterns
+          super + prefix_regexes
+        end
+
+        def prefix_regexes
+          @prefix_regexes ||= prefixes.map { |pre| /^#{Regexp.escape(pre)}\b/ }
+        end
+
+        def description(context)
+          if context.xstr_type?
+            context.value.value
+          else
+            context.value
+          end
         end
 
-        def joined_prefixes
-          quoted = prefixes.map { |prefix| "'#{prefix}'" }
-          return quoted.first if quoted.size == 1
+        def message
+          if allowed_patterns.empty?
+            MSG_ALWAYS
+          else
+            format(MSG_MATCH, patterns: expect_patterns)
+          end
+        end
 
-          quoted << "or #{quoted.pop}"
-          quoted.join(', ')
+        def expect_patterns
+          inspected = allowed_patterns.map do |pattern|
+            pattern.inspect.gsub(/\A"|"\z/, '/')
+          end
+          return inspected.first if inspected.size == 1
+
+          inspected << "or #{inspected.pop}"
+          inspected.join(', ')
         end
 
         def prefixes
-          cop_config['Prefixes'] || []
+          Array(cop_config.fetch('Prefixes', [])).tap do |prefixes|
+            non_strings = prefixes.reject { |pre| pre.is_a?(String) }
+            unless non_strings.empty?
+              raise "Non-string prefixes #{non_strings.inspect} detected."
+            end
+          end
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/cop.rb b/lib/rubocop/cop/rspec/cop.rb
deleted file mode 100644
index 636333212..000000000
--- a/lib/rubocop/cop/rspec/cop.rb
+++ /dev/null
@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop # rubocop:disable Style/Documentation
-    WorkaroundCop = Cop.dup
-
-    # Clone of the the normal RuboCop::Cop::Cop class so we can rewrite
-    # the inherited method without breaking functionality
-    class WorkaroundCop
-      # Remove the Cop.inherited method to be a noop. Our RSpec::Cop
-      # class will invoke the inherited hook instead
-      class << self
-        undef inherited
-        def inherited(*) end
-      end
-
-      # Special case `Module#<` so that the rspec support rubocop exports
-      # is compatible with our subclass
-      def self.<(other)
-        other.equal?(RuboCop::Cop::Cop) || super
-      end
-    end
-    private_constant(:WorkaroundCop)
-
-    module RSpec
-      # @abstract parent class to rspec cops
-      #
-      # The criteria for whether rubocop-rspec analyzes a certain ruby file
-      # is configured via `AllCops/RSpec`. For example, if you want to
-      # customize your project to scan all files within a `test/` directory
-      # then you could add this to your configuration:
-      #
-      # @example configuring analyzed paths
-      #
-      #   AllCops:
-      #     RSpec:
-      #       Patterns:
-      #       - '_test.rb$'
-      #       - '(?:^|/)test/'
-      class Cop < WorkaroundCop
-        include RuboCop::RSpec::Language
-        include RuboCop::RSpec::Language::NodePattern
-
-        DEFAULT_CONFIGURATION =
-          RuboCop::RSpec::CONFIG.fetch('AllCops').fetch('RSpec')
-
-        DEFAULT_PATTERN_RE = Regexp.union(
-          DEFAULT_CONFIGURATION.fetch('Patterns')
-                               .map(&Regexp.public_method(:new))
-        )
-
-        # Invoke the original inherited hook so our cops are recognized
-        def self.inherited(subclass)
-          RuboCop::Cop::Cop.inherited(subclass)
-        end
-
-        def relevant_file?(file)
-          relevant_rubocop_rspec_file?(file) && super
-        end
-
-        private
-
-        def relevant_rubocop_rspec_file?(file)
-          rspec_pattern =~ file
-        end
-
-        def rspec_pattern
-          if rspec_pattern_config?
-            Regexp.union(rspec_pattern_config.map(&Regexp.public_method(:new)))
-          else
-            DEFAULT_PATTERN_RE
-          end
-        end
-
-        def all_cops_config
-          config
-            .for_all_cops
-        end
-
-        def rspec_pattern_config?
-          return unless all_cops_config.key?('RSpec')
-
-          all_cops_config.fetch('RSpec').key?('Patterns')
-        end
-
-        def rspec_pattern_config
-          all_cops_config
-            .fetch('RSpec', DEFAULT_CONFIGURATION)
-            .fetch('Patterns')
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/describe_class.rb b/lib/rubocop/cop/rspec/describe_class.rb
index 101fabecb..ab358678a 100644
--- a/lib/rubocop/cop/rspec/describe_class.rb
+++ b/lib/rubocop/cop/rspec/describe_class.rb
@@ -3,7 +3,19 @@
 module RuboCop
   module Cop
     module RSpec
-      # Check that the first argument to the top level describe is a constant.
+      # Check that the first argument to the top-level describe is a constant.
+      #
+      # It can be configured to ignore strings when certain metadata is passed.
+      #
+      # Ignores Rails and Aruba `type` metadata by default.
+      #
+      # @example `IgnoredMetadata` configuration
+      #   # .rubocop.yml
+      #   # RSpec/DescribeClass:
+      #   #   IgnoredMetadata:
+      #   #     type:
+      #   #       - request
+      #   #       - controller
       #
       # @example
       #   # bad
@@ -12,44 +24,60 @@ module RSpec
       #
       #   # good
       #   describe TestedClass do
+      #     subject { described_class }
+      #   end
+      #
+      #   describe 'TestedClass::VERSION' do
+      #     subject { Object.const_get(self.class.description) }
       #   end
       #
       #   describe "A feature example", type: :feature do
       #   end
-      class DescribeClass < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      #
+      class DescribeClass < Base
+        include TopLevelGroup
 
-        MSG = 'The first argument to describe should be '\
+        MSG = 'The first argument to describe should be ' \
               'the class or module being tested.'
 
-        def_node_matcher :valid_describe?, <<-PATTERN
-          {
-            (send #{RSPEC} :describe const ...)
-            (send #{RSPEC} :describe)
-          }
+        # @!method example_group_with_ignored_metadata?(node)
+        def_node_matcher :example_group_with_ignored_metadata?, <<~PATTERN
+          (send #rspec? :describe ... (hash <#ignored_metadata? ...>))
         PATTERN
 
-        def_node_matcher :describe_with_rails_metadata?, <<-PATTERN
-          (send #{RSPEC} :describe !const ...
-            (hash <#rails_metadata? ...>)
-          )
+        # @!method not_a_const_described(node)
+        def_node_matcher :not_a_const_described, <<~PATTERN
+          (send #rspec? :describe $[!const !#string_constant?] ...)
         PATTERN
 
-        def_node_matcher :rails_metadata?, <<-PATTERN
-          (pair
-            (sym :type)
-            (sym {:request :feature :system :routing :view})
-          )
+        # @!method sym_pair(node)
+        def_node_matcher :sym_pair, <<~PATTERN
+          (pair $sym $sym)
         PATTERN
 
-        def_node_matcher :shared_group?, SharedGroups::ALL.block_pattern
+        def on_top_level_group(node)
+          return if example_group_with_ignored_metadata?(node.send_node)
 
-        def on_top_level_describe(node, args)
-          return if shared_group?(root_node)
-          return if valid_describe?(node)
-          return if describe_with_rails_metadata?(node)
+          not_a_const_described(node.send_node) do |described|
+            add_offense(described)
+          end
+        end
+
+        private
+
+        def ignored_metadata?(node)
+          sym_pair(node) do |key, value|
+            ignored_metadata[key.value.to_s].to_a.include?(value.value.to_s)
+          end
+        end
+
+        def string_constant?(described)
+          described.str_type? &&
+            described.value.match?(/^(?:(?:::)?[A-Z]\w*)+$/)
+        end
 
-          add_offense(args.first)
+        def ignored_metadata
+          cop_config['IgnoredMetadata'] || {}
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/describe_method.rb b/lib/rubocop/cop/rspec/describe_method.rb
index 7a32739e9..eecc763af 100644
--- a/lib/rubocop/cop/rspec/describe_method.rb
+++ b/lib/rubocop/cop/rspec/describe_method.rb
@@ -16,17 +16,35 @@ module RSpec
       #
       #   describe MyClass, '.my_class_method' do
       #   end
-      class DescribeMethod < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      #
+      class DescribeMethod < Base
+        include TopLevelGroup
 
-        MSG = 'The second argument to describe should be the method '\
+        MSG = 'The second argument to describe should be the method ' \
               "being tested. '#instance' or '.class'."
 
-        def on_top_level_describe(_node, (_, second_arg))
-          return unless second_arg&.str_type?
-          return if second_arg.str_content.start_with?('#', '.')
+        # @!method second_string_literal_argument(node)
+        def_node_matcher :second_string_literal_argument, <<~PATTERN
+          (block
+            (send #rspec? :describe _first_argument ${str dstr} ...)
+          ...)
+        PATTERN
+
+        # @!method method_name?(node)
+        def_node_matcher :method_name?, <<~PATTERN
+          {(str #method_name_prefix?) (dstr (str #method_name_prefix?) ...)}
+        PATTERN
+
+        def on_top_level_group(node)
+          second_string_literal_argument(node) do |argument|
+            add_offense(argument) unless method_name?(argument)
+          end
+        end
+
+        private
 
-          add_offense(second_arg)
+        def method_name_prefix?(description)
+          description.start_with?('.', '#')
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/describe_symbol.rb b/lib/rubocop/cop/rspec/describe_symbol.rb
index 4bffa63fe..44a0b7f15 100644
--- a/lib/rubocop/cop/rspec/describe_symbol.rb
+++ b/lib/rubocop/cop/rspec/describe_symbol.rb
@@ -17,11 +17,13 @@ module RSpec
       #   end
       #
       # @see https://github.com/rspec/rspec-core/issues/1610
-      class DescribeSymbol < Cop
+      class DescribeSymbol < Base
         MSG = 'Avoid describing symbols.'
+        RESTRICT_ON_SEND = %i[describe].freeze
 
-        def_node_matcher :describe_symbol?, <<-PATTERN
-          (send #{RSPEC} :describe $sym ...)
+        # @!method describe_symbol?(node)
+        def_node_matcher :describe_symbol?, <<~PATTERN
+          (send #rspec? :describe $sym ...)
         PATTERN
 
         def on_send(node)
diff --git a/lib/rubocop/cop/rspec/described_class.rb b/lib/rubocop/cop/rspec/described_class.rb
index cbe453858..598c2f975 100644
--- a/lib/rubocop/cop/rspec/described_class.rb
+++ b/lib/rubocop/cop/rspec/described_class.rb
@@ -8,10 +8,12 @@ module RSpec
       # If the first argument of describe is a class, the class is exposed to
       # each example via described_class.
       #
-      # This cop can be configured using the `EnforcedStyle` and `SkipBlocks`
-      # options.
+      # This cop can be configured using the `EnforcedStyle`, `SkipBlocks`
+      # and `OnlyStaticConstants` options.
+      # `OnlyStaticConstants` is only relevant when `EnforcedStyle` is
+      # `described_class`.
       #
-      # @example `EnforcedStyle: described_class`
+      # @example `EnforcedStyle: described_class` (default)
       #   # bad
       #   describe MyClass do
       #     subject { MyClass.do_something }
@@ -22,6 +24,18 @@ module RSpec
       #     subject { described_class.do_something }
       #   end
       #
+      # @example `OnlyStaticConstants: true` (default)
+      #   # good
+      #   describe MyClass do
+      #     subject { MyClass::CONSTANT }
+      #   end
+      #
+      # @example `OnlyStaticConstants: false`
+      #   # bad
+      #   describe MyClass do
+      #     subject { MyClass::CONSTANT }
+      #   end
+      #
       # @example `EnforcedStyle: explicit`
       #   # bad
       #   describe MyClass do
@@ -54,30 +68,36 @@ module RSpec
       #     end
       #   end
       #
-      class DescribedClass < Cop
+      class DescribedClass < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
+        include Namespace
 
         DESCRIBED_CLASS = 'described_class'
         MSG             = 'Use `%<replacement>s` instead of `%<src>s`.'
 
-        def_node_matcher :common_instance_exec_closure?, <<-PATTERN
+        # @!method common_instance_exec_closure?(node)
+        def_node_matcher :common_instance_exec_closure?, <<~PATTERN
           (block (send (const nil? {:Class :Module :Struct}) :new ...) ...)
         PATTERN
 
+        # @!method rspec_block?(node)
         def_node_matcher :rspec_block?,
-                         RuboCop::RSpec::Language::ALL.block_pattern
+                         '(any_block (send #rspec? #ALL.all ...) ...)'
 
+        # @!method scope_changing_syntax?(node)
         def_node_matcher :scope_changing_syntax?, '{def class module}'
 
-        def_node_matcher :described_constant, <<-PATTERN
+        # @!method described_constant(node)
+        def_node_matcher :described_constant, <<~PATTERN
           (block (send _ :describe $(const ...) ...) (args) $_)
         PATTERN
 
-        def_node_search :contains_described_class?, <<-PATTERN
-          (send nil? :described_class)
-        PATTERN
+        # @!method contains_described_class?(node)
+        def_node_search :contains_described_class?,
+                        '(send nil? :described_class)'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           # In case the explicit style is used, we need to remember what's
           # being described.
           @described_class, body = described_constant(node)
@@ -85,33 +105,38 @@ def on_block(node)
           return unless body
 
           find_usage(body) do |match|
-            add_offense(match, message: message(match.const_name))
+            msg = message(match.const_name)
+            add_offense(match, message: msg) do |corrector|
+              autocorrect(corrector, match)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, match)
           replacement = if style == :described_class
                           DESCRIBED_CLASS
                         else
                           @described_class.const_name
                         end
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
 
-        private
+          corrector.replace(match, replacement)
+        end
 
         def find_usage(node, &block)
           yield(node) if offensive?(node)
-
-          return if scope_change?(node) || node.const_type?
+          return if scope_change?(node) || allowed?(node)
 
           node.each_child_node do |child|
             find_usage(child, &block)
           end
         end
 
+        def allowed?(node)
+          node.const_type? && only_static_constants?
+        end
+
         def message(offense)
           if style == :described_class
             format(MSG, replacement: DESCRIBED_CLASS, src: offense)
@@ -122,42 +147,46 @@ def message(offense)
         end
 
         def scope_change?(node)
-          scope_changing_syntax?(node)          ||
+          scope_changing_syntax?(node) ||
             common_instance_exec_closure?(node) ||
             skippable_block?(node)
         end
 
         def skippable_block?(node)
-          node.block_type? && !rspec_block?(node) && skip_blocks?
+          return false unless cop_config['SkipBlocks']
+
+          node.any_block_type? && !rspec_block?(node)
         end
 
-        def skip_blocks?
-          cop_config['SkipBlocks']
+        def only_static_constants?
+          cop_config.fetch('OnlyStaticConstants', true)
         end
 
         def offensive?(node)
           if style == :described_class
             offensive_described_class?(node)
           else
-            node.send_type? && node.method_name == :described_class
+            node.send_type? && node.method?(:described_class)
           end
         end
 
         def offensive_described_class?(node)
-          return unless node.const_type?
+          return false unless node.const_type?
+
           # E.g. `described_class::CONSTANT`
-          return if contains_described_class?(node)
+          return false if contains_described_class?(node)
 
           nearest_described_class, = node.each_ancestor(:block)
             .map { |ancestor| described_constant(ancestor) }.find(&:itself)
 
-          return if nearest_described_class.equal?(node)
+          return false if nearest_described_class.equal?(node)
 
           full_const_name(nearest_described_class) == full_const_name(node)
         end
 
         def full_const_name(node)
-          collapse_namespace(namespace(node), const_name(node))
+          symbolized_namespace = namespace(node).map(&:to_sym)
+          collapse_namespace(symbolized_namespace, const_name(node))
         end
 
         # @param namespace [Array<Symbol>]
@@ -165,14 +194,13 @@ def full_const_name(node)
         # @return [Array<Symbol>]
         # @example
         #   # nil represents base constant
-        #   collapse_namespace([], :C)                 # => [:C]
-        #   collapse_namespace([:A, :B], [:C)          # => [:A, :B, :C]
-        #   collapse_namespace([:A, :B], [:B, :C)      # => [:A, :B, :C]
-        #   collapse_namespace([:A, :B], [nil, :C)     # => [nil, :C]
-        #   collapse_namespace([:A, :B], [nil, :B, :C) # => [nil, :B, :C]
+        #   collapse_namespace([], [:C])                # => [:C]
+        #   collapse_namespace([:A, :B], [:C])          # => [:A, :B, :C]
+        #   collapse_namespace([:A, :B], [:B, :C])      # => [:A, :B, :C]
+        #   collapse_namespace([:A, :B], [nil, :C])     # => [nil, :C]
+        #   collapse_namespace([:A, :B], [nil, :B, :C]) # => [nil, :B, :C]
         def collapse_namespace(namespace, const)
-          return const if namespace.empty?
-          return const if const.first.nil?
+          return const if namespace.empty? || const.first.nil?
 
           start = [0, (namespace.length - const.length)].max
           max = namespace.length
@@ -189,29 +217,16 @@ def collapse_namespace(namespace, const)
         #   const_name(s(:const, s(:const, nil, :M), :C)) # => [:M, :C]
         #   const_name(s(:const, s(:cbase), :C))          # => [nil, :C]
         def const_name(node)
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          namespace, name = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
+          namespace = node.namespace
+          name = node.short_name
           if !namespace
             [name]
           elsif namespace.const_type?
             [*const_name(namespace), name]
-          elsif namespace.lvar_type? || namespace.cbase_type?
+          elsif %i[lvar cbase send].include?(namespace.type)
             [nil, name]
           end
         end
-
-        # @param node [RuboCop::AST::Node]
-        # @return [Array<Symbol>]
-        # @example
-        #   namespace(node) # => [:A, :B, :C]
-        def namespace(node)
-          node
-            .each_ancestor(:class, :module)
-            .reverse_each
-            .flat_map { |ancestor| ancestor.defined_module_name.split('::') }
-            .map(&:to_sym)
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/described_class_module_wrapping.rb b/lib/rubocop/cop/rspec/described_class_module_wrapping.rb
index e1d548ce5..9ea0a786d 100644
--- a/lib/rubocop/cop/rspec/described_class_module_wrapping.rb
+++ b/lib/rubocop/cop/rspec/described_class_module_wrapping.rb
@@ -18,17 +18,19 @@ module RSpec
       #     # ...
       #   end
       #
-      # @see https://github.com/rubocop-hq/rubocop-rspec/issues/735
-      class DescribedClassModuleWrapping < Cop
+      # @see https://github.com/rubocop/rubocop-rspec/issues/735
+      class DescribedClassModuleWrapping < Base
         MSG = 'Avoid opening modules and defining specs within them.'
 
-        def_node_search :find_rspec_blocks,
-                        ExampleGroups::ALL.block_pattern
+        # @!method include_rspec_blocks?(node)
+        def_node_search :include_rspec_blocks?, <<~PATTERN
+          (any_block (send #explicit_rspec? #ExampleGroups.all ...) ...)
+        PATTERN
 
         def on_module(node)
-          find_rspec_blocks(node) do
-            add_offense(node)
-          end
+          return unless include_rspec_blocks?(node)
+
+          add_offense(node)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/dialect.rb b/lib/rubocop/cop/rspec/dialect.rb
index 137359483..5bc91f0cc 100644
--- a/lib/rubocop/cop/rspec/dialect.rb
+++ b/lib/rubocop/cop/rspec/dialect.rb
@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # This cop enforces custom RSpec dialects.
+      # Enforces custom RSpec dialects.
       #
       # A dialect can be based on the following RSpec methods:
       #
@@ -29,6 +29,19 @@ module RSpec
       #     PreferredMethods:
       #       context: describe
       #
+      # If you were previously using the `RSpec/Capybara/FeatureMethods` cop and
+      # want to keep disabling all Capybara-specific methods that have the same
+      # native RSpec method (e.g. are just aliases), use the following config:
+      #
+      #   RSpec/Dialect:
+      #     PreferredMethods:
+      #       background: :before
+      #       scenario:   :it
+      #       xscenario:  :xit
+      #       given:      :let
+      #       given!:     :let!
+      #       feature:    :describe
+      #
       # You can expect the following behavior:
       #
       # @example
@@ -41,35 +54,30 @@ module RSpec
       #   describe 'display name presence' do
       #     # ...
       #   end
-      class Dialect < Cop
+      #
+      class Dialect < Base
+        extend AutoCorrector
         include MethodPreference
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
-        def_node_matcher :rspec_method?, ALL.send_pattern
+        # @!method rspec_method?(node)
+        def_node_matcher :rspec_method?, '(send #rspec? #ALL.all ...)'
 
         def on_send(node)
           return unless rspec_method?(node)
           return unless preferred_methods[node.method_name]
 
-          add_offense(node)
-        end
+          msg = format(MSG, prefer: preferred_method(node.method_name),
+                            current: node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: msg) do |corrector|
             current = node.loc.selector
             preferred = preferred_method(current.source)
 
             corrector.replace(current, preferred)
           end
         end
-
-        private
-
-        def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/duplicated_metadata.rb b/lib/rubocop/cop/rspec/duplicated_metadata.rb
new file mode 100644
index 000000000..7363946eb
--- /dev/null
+++ b/lib/rubocop/cop/rspec/duplicated_metadata.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid duplicated metadata.
+      #
+      # @example
+      #   # bad
+      #   describe 'Something', :a, :a
+      #
+      #   # good
+      #   describe 'Something', :a
+      class DuplicatedMetadata < Base
+        extend AutoCorrector
+
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Avoid duplicated metadata.'
+
+        def on_metadata(symbols, _hash)
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol)
+          end
+        end
+
+        private
+
+        def on_metadata_symbol(node)
+          return unless duplicated?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def duplicated?(node)
+          node.left_siblings.any? do |sibling|
+            sibling.eql?(node)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/empty_example_group.rb b/lib/rubocop/cop/rspec/empty_example_group.rb
index 2d8bb24f4..3e0d7878e 100644
--- a/lib/rubocop/cop/rspec/empty_example_group.rb
+++ b/lib/rubocop/cop/rspec/empty_example_group.rb
@@ -5,10 +5,7 @@ module Cop
     module RSpec
       # Checks if an example group does not include any tests.
       #
-      # This cop is configurable using the `CustomIncludeMethods` option
-      #
       # @example usage
-      #
       #   # bad
       #   describe Bacon do
       #     let(:bacon)      { Bacon.new(chunkiness) }
@@ -33,56 +30,158 @@ module RSpec
       #     end
       #   end
       #
-      # @example configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/EmptyExampleGroup:
-      #   #   CustomIncludeMethods:
-      #   #   - include_tests
-      #
-      #   # spec_helper.rb
-      #   RSpec.configure do |config|
-      #     config.alias_it_behaves_like_to(:include_tests)
-      #   end
-      #
-      #   # bacon_spec.rb
+      #   # good
       #   describe Bacon do
-      #     let(:bacon)      { Bacon.new(chunkiness) }
-      #     let(:chunkiness) { false                 }
-      #
-      #     context 'extra chunky' do   # not flagged by rubocop
-      #       let(:chunkiness) { true }
-      #
-      #       include_tests 'shared tests'
-      #     end
+      #     pending 'will add tests later'
       #   end
       #
-      class EmptyExampleGroup < Cop
+      class EmptyExampleGroup < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = 'Empty example group detected.'
 
-        def_node_search :contains_example?, <<-PATTERN
+        # @!method example_group_body(node)
+        #   Match example group blocks and yield their body
+        #
+        #   @example source that matches
+        #     describe 'example group' do
+        #       it { is_expected.to be }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] example group body
+        def_node_matcher :example_group_body, <<~PATTERN
+          (block (send #rspec? #ExampleGroups.all ...) args $_)
+        PATTERN
+
+        # @!method example_or_group_or_include?(node)
+        #   Match examples, example groups and includes
+        #
+        #   @example source that matches
+        #     it { is_expected.to fly }
+        #     describe('non-empty example groups too') { }
+        #     it_behaves_like 'an animal'
+        #     it_behaves_like('a cat') { let(:food) { 'milk' } }
+        #     it_has_root_access
+        #     skip
+        #     it 'will be implemented later'
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :example_or_group_or_include?, <<~PATTERN
           {
-            #{(Examples::ALL + Includes::ALL).send_pattern}
-            (send _ #custom_include? ...)
+            (block
+              (send #rspec? {#Examples.all #ExampleGroups.all #Includes.all} ...)
+            ...)
+            (send nil? {#Examples.all #Includes.all} ...)
           }
         PATTERN
 
-        def on_block(node)
-          return unless example_group?(node) && !contains_example?(node)
+        # @!method examples_inside_block?(node)
+        #   Match examples defined inside a block which is not a hook
+        #
+        #   @example source that matches
+        #     %w(r g b).each do |color|
+        #       it { is_expected.to have_color(color) }
+        #     end
+        #
+        #   @example source that does not match
+        #     before do
+        #       it { is_expected.to fall_into_oblivion }
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_inside_block?, <<~PATTERN
+          (block !(send nil? #Hooks.all ...) _ #examples?)
+        PATTERN
 
-          add_offense(node.send_node)
+        # @!method examples_directly_or_in_block?(node)
+        #   Match examples or examples inside blocks
+        #
+        #   @example source that matches
+        #     it { expect(drink).to be_cold }
+        #     context('when winter') { it { expect(drink).to be_hot } }
+        #     (1..5).each { |divisor| it { is_expected.to divide_by(divisor) } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples_directly_or_in_block?, <<~PATTERN
+          {
+            #example_or_group_or_include?
+            #examples_inside_block?
+          }
+        PATTERN
+
+        # @!method examples?(node)
+        #   Matches examples defined in scopes where they could run
+        #
+        #   @example source that matches
+        #     it { expect(myself).to be_run }
+        #     describe { it { i_run_as_well } }
+        #
+        #   @example source that does not match
+        #     before { it { whatever here won't run anyway } }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :examples?, <<~PATTERN
+          {
+            #examples_directly_or_in_block?
+            #examples_in_branches?
+            (begin <#examples_directly_or_in_block? ...>)
+            (begin <#examples_in_branches? ...>)
+          }
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return if node.each_ancestor(:any_def).any?
+          return if node.each_ancestor(:block).any? { |block| example?(block) }
+
+          example_group_body(node) do |body|
+            next unless offensive?(body)
+
+            add_offense(node.send_node) do |corrector|
+              corrector.remove(removed_range(node))
+            end
+          end
         end
 
         private
 
-        def custom_include?(method_name)
-          custom_include_methods.include?(method_name)
+        def offensive?(body)
+          return true unless body
+          return false if conditionals_with_examples?(body)
+
+          if body.type?(:if, :case)
+            !examples_in_branches?(body)
+          else
+            !examples?(body)
+          end
+        end
+
+        def conditionals_with_examples?(body)
+          return false unless body.type?(:begin, :case)
+
+          body.each_descendant(:if, :case).any? do |condition_node|
+            examples_in_branches?(condition_node)
+          end
+        end
+
+        def examples_in_branches?(condition_node)
+          return false unless condition_node
+          return false unless condition_node.type?(:if, :case)
+
+          condition_node.branches.any? { |branch| examples?(branch) }
         end
 
-        def custom_include_methods
-          cop_config
-            .fetch('CustomIncludeMethods', [])
-            .map(&:to_sym)
+        def removed_range(node)
+          range_by_whole_lines(
+            node.source_range,
+            include_final_newline: true
+          )
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/empty_hook.rb b/lib/rubocop/cop/rspec/empty_hook.rb
new file mode 100644
index 000000000..6dae31aea
--- /dev/null
+++ b/lib/rubocop/cop/rspec/empty_hook.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for empty before and after hooks.
+      #
+      # @example
+      #   # bad
+      #   before {}
+      #   after do; end
+      #   before(:all) do
+      #   end
+      #   after(:all) { }
+      #
+      #   # good
+      #   before { create_users }
+      #   after do
+      #     cleanup_users
+      #   end
+      #   before(:all) do
+      #     create_feed
+      #   end
+      #   after(:all) { cleanup_feed }
+      #
+      class EmptyHook < Base
+        extend AutoCorrector
+        include RuboCop::Cop::RangeHelp
+
+        MSG = 'Empty hook detected.'
+
+        # @!method empty_hook?(node)
+        def_node_matcher :empty_hook?, <<~PATTERN
+          (block $(send nil? #Hooks.all ...) _ nil?)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          empty_hook?(node) do |hook|
+            add_offense(hook) do |corrector|
+              corrector.remove(
+                range_with_surrounding_space(node.source_range, side: :left)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_example.rb b/lib/rubocop/cop/rspec/empty_line_after_example.rb
index 7ddd05632..5603f1463 100644
--- a/lib/rubocop/cop/rspec/empty_line_after_example.rb
+++ b/lib/rubocop/cop/rspec/empty_line_after_example.rb
@@ -30,7 +30,6 @@ module RSpec
       #   end
       #
       # @example with AllowConsecutiveOneLiners configuration
-      #
       #   # rubocop.yml
       #   # RSpec/EmptyLineAfterExample:
       #   #   AllowConsecutiveOneLiners: false
@@ -41,23 +40,23 @@ module RSpec
       #     it { two }
       #   end
       #
-      class EmptyLineAfterExample < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterExample < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<example>s`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example?(node)
-          return if last_child?(node)
           return if allowed_one_liner?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(node,
-                        location: location,
-                        message: format(MSG, example: node.method_name))
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example: method)
           end
         end
 
+        private
+
         def allowed_one_liner?(node)
           consecutive_one_liner?(node) && allow_consecutive_one_liners?
         end
@@ -67,19 +66,15 @@ def allow_consecutive_one_liners?
         end
 
         def consecutive_one_liner?(node)
-          node.line_count == 1 && next_one_line_example?(node)
+          node.single_line? && next_one_line_example?(node)
         end
 
         def next_one_line_example?(node)
-          next_sibling = next_sibling(node)
-          return unless next_sibling
-          return unless example?(next_sibling)
-
-          next_sibling.line_count == 1
-        end
+          next_sibling = node.right_sibling
+          return false unless next_sibling
+          return false unless example?(next_sibling)
 
-        def next_sibling(node)
-          node.parent.children[node.sibling_index + 1]
+          next_sibling.single_line?
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_example_group.rb b/lib/rubocop/cop/rspec/empty_line_after_example_group.rb
index 7b87add04..d7dadc35a 100644
--- a/lib/rubocop/cop/rspec/empty_line_after_example_group.rb
+++ b/lib/rubocop/cop/rspec/empty_line_after_example_group.rb
@@ -23,21 +23,17 @@ module RSpec
       #     end
       #   end
       #
-      class EmptyLineAfterExampleGroup < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterExampleGroup < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<example_group>s`.'
 
-        def on_block(node)
-          return unless example_group?(node)
-          return if last_child?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(
-              node,
-              location: location,
-              message: format(MSG, example_group: node.method_name)
-            )
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example_group: method)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_final_let.rb b/lib/rubocop/cop/rspec/empty_line_after_final_let.rb
index a059433ae..72f0fc185 100644
--- a/lib/rubocop/cop/rspec/empty_line_after_final_let.rb
+++ b/lib/rubocop/cop/rspec/empty_line_after_final_let.rb
@@ -16,21 +16,22 @@ module RSpec
       #   let(:something) { other }
       #
       #   it { does_something }
-      class EmptyLineAfterFinalLet < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      #
+      class EmptyLineAfterFinalLet < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
 
-        MSG = 'Add an empty line after the last `let` block.'
+        MSG = 'Add an empty line after the last `%<let>s`.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 
-          latest_let = node.body.child_nodes.select { |child| let?(child) }.last
+          final_let = node.body.child_nodes.reverse.find { |child| let?(child) }
 
-          return if latest_let.nil?
-          return if last_child?(latest_let)
+          return if final_let.nil?
 
-          missing_separating_line(latest_let) do |location|
-            add_offense(latest_let, location: location)
+          missing_separating_line_offense(final_let) do |method|
+            format(MSG, let: method)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_hook.rb b/lib/rubocop/cop/rspec/empty_line_after_hook.rb
index 678534317..cfcd8d30a 100644
--- a/lib/rubocop/cop/rspec/empty_line_after_hook.rb
+++ b/lib/rubocop/cop/rspec/empty_line_after_hook.rb
@@ -5,6 +5,9 @@ module Cop
     module RSpec
       # Checks if there is an empty line after hook blocks.
       #
+      # `AllowConsecutiveOneLiners` configures whether adjacent
+      # one-line definitions are considered an offense.
+      #
       # @example
       #   # bad
       #   before { do_something }
@@ -19,11 +22,23 @@ module RSpec
       #   it { does_something }
       #
       #   # good
-      #   before { do_something }
+      #   after { do_something }
       #
       #   it { does_something }
       #
-      #   # good
+      #   # fair - it's ok to have non-separated one-liners hooks
+      #   around { |test| test.run }
+      #   after { do_something }
+      #
+      #   it { does_something }
+      #
+      # @example with AllowConsecutiveOneLiners configuration
+      #   # rubocop.yml
+      #   # RSpec/EmptyLineAfterHook:
+      #   #   AllowConsecutiveOneLiners: false
+      #
+      #   # bad
+      #   around { |test| test.run }
       #   after { do_something }
       #
       #   it { does_something }
@@ -31,25 +46,36 @@ module RSpec
       #   # good
       #   around { |test| test.run }
       #
+      #   after { do_something }
+      #
       #   it { does_something }
       #
-      class EmptyLineAfterHook < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterHook < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<hook>s`.'
 
         def on_block(node)
           return unless hook?(node)
-          return if last_child?(node)
-
-          missing_separating_line(node) do |location|
-            add_offense(
-              node,
-              location: location,
-              message: format(MSG, hook: node.method_name)
-            )
+          return if cop_config['AllowConsecutiveOneLiners'] &&
+            chained_single_line_hooks?(node)
+
+          missing_separating_line_offense(node) do |method|
+            format(MSG, hook: method)
           end
         end
+
+        alias on_numblock on_block
+
+        private
+
+        def chained_single_line_hooks?(node)
+          next_node = node.right_sibling
+
+          hook?(next_node) && node.single_line? && next_node.single_line?
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/empty_line_after_subject.rb b/lib/rubocop/cop/rspec/empty_line_after_subject.rb
index a0f6ed0f5..f232e3fa5 100644
--- a/lib/rubocop/cop/rspec/empty_line_after_subject.rb
+++ b/lib/rubocop/cop/rspec/empty_line_after_subject.rb
@@ -14,25 +14,20 @@ module RSpec
       #   subject(:obj) { described_class }
       #
       #   let(:foo) { bar }
-      class EmptyLineAfterSubject < Cop
-        include RuboCop::RSpec::BlankLineSeparation
-
-        MSG = 'Add empty line after `subject`.'
-
-        def on_block(node)
-          return unless subject?(node) && !in_spec_block?(node)
-          return if last_child?(node)
+      #
+      class EmptyLineAfterSubject < Base
+        extend AutoCorrector
+        include EmptyLineSeparation
+        include InsideExampleGroup
 
-          missing_separating_line(node) do |location|
-            add_offense(node, location: location)
-          end
-        end
+        MSG = 'Add an empty line after `%<subject>s`.'
 
-        private
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless subject?(node)
+          return unless inside_example_group?(node)
 
-        def in_spec_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            Examples::ALL.include?(ancestor.method_name)
+          missing_separating_line_offense(node) do |method|
+            format(MSG, subject: method)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/empty_metadata.rb b/lib/rubocop/cop/rspec/empty_metadata.rb
new file mode 100644
index 000000000..390059c31
--- /dev/null
+++ b/lib/rubocop/cop/rspec/empty_metadata.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Avoid empty metadata hash.
+      #
+      # @example EnforcedStyle: symbol (default)
+      #   # bad
+      #   describe 'Something', {}
+      #
+      #   # good
+      #   describe 'Something'
+      class EmptyMetadata < Base
+        extend AutoCorrector
+
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Avoid empty metadata hash.'
+
+        def on_metadata(_symbols, hash)
+          return unless hash&.pairs&.empty?
+          return if hash.children.any?(&:kwsplat_type?)
+
+          add_offense(hash) do |corrector|
+            remove_empty_metadata(corrector, hash)
+          end
+        end
+
+        private
+
+        def remove_empty_metadata(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/empty_output.rb b/lib/rubocop/cop/rspec/empty_output.rb
new file mode 100644
index 000000000..f70d3de21
--- /dev/null
+++ b/lib/rubocop/cop/rspec/empty_output.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check that the `output` matcher is not called with an empty string.
+      #
+      # @example
+      #   # bad
+      #   expect { foo }.to output('').to_stdout
+      #   expect { bar }.not_to output('').to_stderr
+      #
+      #   # good
+      #   expect { foo }.not_to output.to_stdout
+      #   expect { bar }.to output.to_stderr
+      #
+      class EmptyOutput < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<runner>s` instead of matching on an empty output.'
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method matching_empty_output(node)
+        def_node_matcher :matching_empty_output, <<~PATTERN
+          (send
+            (block
+              (send nil? :expect) ...
+            )
+            #Runners.all
+            (send $(send nil? :output (str empty?)) ...)
+          )
+        PATTERN
+
+        def on_send(send_node)
+          matching_empty_output(send_node) do |node|
+            runner = send_node.method?(:to) ? 'not_to' : 'to'
+            message = format(MSG, runner: runner)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(send_node.loc.selector, runner)
+              corrector.replace(node, 'output')
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/eq.rb b/lib/rubocop/cop/rspec/eq.rb
new file mode 100644
index 000000000..f56176548
--- /dev/null
+++ b/lib/rubocop/cop/rspec/eq.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use `eq` instead of `be ==` to compare objects.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be == 42
+      #
+      #   # good
+      #   expect(foo).to eq 42
+      #
+      class Eq < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `eq` instead of `be ==` to compare objects.'
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method be_equals(node)
+        def_node_matcher :be_equals, <<~PATTERN
+          (send _ #Runners.all $(send (send nil? :be) :== _))
+        PATTERN
+
+        def on_send(node)
+          be_equals(node) do |matcher|
+            range = offense_range(matcher)
+            add_offense(range) do |corrector|
+              corrector.replace(range, 'eq')
+            end
+          end
+        end
+
+        private
+
+        def offense_range(matcher)
+          range_between(
+            matcher.source_range.begin_pos,
+            matcher.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/example_length.rb b/lib/rubocop/cop/rspec/example_length.rb
index 1bfb2dde3..880030935 100644
--- a/lib/rubocop/cop/rspec/example_length.rb
+++ b/lib/rubocop/cop/rspec/example_length.rb
@@ -6,7 +6,7 @@ module RSpec
       # Checks for long examples.
       #
       # A long example is usually more difficult to understand. Consider
-      # extracting out some behaviour, e.g. with a `let` block, or a helper
+      # extracting out some behavior, e.g. with a `let` block, or a helper
       # method.
       #
       # @example
@@ -25,29 +25,50 @@ module RSpec
       #     result = service.call
       #     expect(result).to be(true)
       #   end
-      class ExampleLength < Cop
+      #
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of
+      # its actual size.
+      #
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
+      #
+      #   it do
+      #     array = [         # +1
+      #       1,
+      #       2
+      #     ]
+      #
+      #     hash = {          # +3
+      #       key: 'value'
+      #     }
+      #
+      #     msg = <<~HEREDOC  # +1
+      #       Heredoc
+      #       content.
+      #     HEREDOC
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
+      #
+      class ExampleLength < Base
         include CodeLength
 
-        MSG = 'Example has too many lines [%<total>d/%<max>d].'
+        LABEL = 'Example'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example?(node)
 
-          length = code_length(node)
-
-          return unless length > max_length
-
-          add_offense(node, message: message(length))
+          check_code_length(node)
         end
 
         private
 
-        def code_length(node)
-          node.source.lines[1..-2].count { |line| !irrelevant_line(line) }
-        end
-
-        def message(length)
-          format(MSG, total: length, max: max_length)
+        def cop_label
+          LABEL
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/example_without_description.rb b/lib/rubocop/cop/rspec/example_without_description.rb
index 8d4ace983..e53d574b1 100644
--- a/lib/rubocop/cop/rspec/example_without_description.rb
+++ b/lib/rubocop/cop/rspec/example_without_description.rb
@@ -7,6 +7,7 @@ module RSpec
       #
       # RSpec allows for auto-generated example descriptions when there is no
       # description provided or the description is an empty one.
+      # It is acceptable to use `specify` without a description
       #
       # This cop removes empty descriptions.
       # It also defines whether auto-generated description is allowed, based
@@ -14,17 +15,24 @@ module RSpec
       #
       # This cop can be configured using the `EnforcedStyle` option
       #
-      # @example `EnforcedStyle: always_allow`
+      # @example
+      #   # always good
+      #   specify do
+      #     result = service.call
+      #     expect(result).to be(true)
+      #   end
+      #
+      # @example `EnforcedStyle: always_allow` (default)
       #   # bad
       #   it('') { is_expected.to be_good }
-      #   it '' do
+      #   specify '' do
       #     result = service.call
       #     expect(result).to be(true)
       #   end
       #
       #   # good
       #   it { is_expected.to be_good }
-      #   it do
+      #   specify do
       #     result = service.call
       #     expect(result).to be(true)
       #   end
@@ -47,16 +55,18 @@ module RSpec
       #     result = service.call
       #     expect(result).to be(true)
       #   end
-      class ExampleWithoutDescription < Cop
+      #
+      class ExampleWithoutDescription < Base
         include ConfigurableEnforcedStyle
 
         MSG_DEFAULT_ARGUMENT = 'Omit the argument when you want to ' \
                                'have auto-generated description.'
         MSG_ADD_DESCRIPTION  = 'Add a description.'
 
+        # @!method example_description(node)
         def_node_matcher :example_description, '(send nil? _ $(str $_))'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example?(node)
 
           check_example_without_description(node.send_node)
@@ -73,6 +83,7 @@ def on_block(node)
         def check_example_without_description(node)
           return if node.arguments?
           return unless disallow_empty_description?(node)
+          return if node.method?(:specify) && node.parent.multiline?
 
           add_offense(node, message: MSG_ADD_DESCRIPTION)
         end
diff --git a/lib/rubocop/cop/rspec/example_wording.rb b/lib/rubocop/cop/rspec/example_wording.rb
index 5407544e9..dfbccb744 100644
--- a/lib/rubocop/cop/rspec/example_wording.rb
+++ b/lib/rubocop/cop/rspec/example_wording.rb
@@ -6,17 +6,25 @@ module RSpec
       # Checks for common mistakes in example descriptions.
       #
       # This cop will correct docstrings that begin with 'should' and 'it'.
+      # This cop will also look for insufficient examples and call them out.
       #
       # @see http://betterspecs.org/#should
       #
       # The autocorrect is experimental - use with care! It can be configured
       # with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
       #
+      # Use the DisallowedExamples setting to prevent unclear or insufficient
+      # descriptions. Please note that this config will not be treated as
+      # case sensitive.
+      #
       # @example
       #   # bad
       #   it 'should find nothing' do
       #   end
       #
+      #   it 'will find nothing' do
+      #   end
+      #
       #   # good
       #   it 'finds nothing' do
       #   end
@@ -29,44 +37,65 @@ module RSpec
       #   # good
       #   it 'does things' do
       #   end
-      class ExampleWording < Cop
+      #
+      # @example `DisallowedExamples: ['works']` (default)
+      #   # bad
+      #   it 'works' do
+      #   end
+      #
+      #   # good
+      #   it 'marks the task as done' do
+      #   end
+      class ExampleWording < Base
+        extend AutoCorrector
+
         MSG_SHOULD = 'Do not use should when describing your tests.'
+        MSG_WILL   = 'Do not use the future tense when describing your tests.'
         MSG_IT     = "Do not repeat 'it' when describing your tests."
+        MSG_INSUFFICIENT_DESCRIPTION = 'Your example description is ' \
+                                       'insufficient.'
 
-        SHOULD_PREFIX = /\Ashould(?:n't)?\b/i.freeze
+        SHOULD_PREFIX = /\Ashould(?:n't|n’t)?\b/i.freeze
+        WILL_PREFIX   = /\A(?:will|won't|won’t)\b/i.freeze
         IT_PREFIX     = /\Ait /i.freeze
 
-        def_node_matcher :it_description, <<-PATTERN
+        # @!method it_description(node)
+        def_node_matcher :it_description, <<~PATTERN
           (block (send _ :it ${
             (str $_)
             (dstr (str $_ ) ...)
           } ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           it_description(node) do |description_node, message|
-            if message =~ SHOULD_PREFIX
+            if message.match?(SHOULD_PREFIX)
               add_wording_offense(description_node, MSG_SHOULD)
-            elsif message =~ IT_PREFIX
+            elsif message.match?(WILL_PREFIX)
+              add_wording_offense(description_node, MSG_WILL)
+            elsif message.match?(IT_PREFIX)
               add_wording_offense(description_node, MSG_IT)
+            elsif insufficient_docstring?(description_node)
+              add_offense(docstring(description_node),
+                          message: MSG_INSUFFICIENT_DESCRIPTION)
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(docstring(node), replacement_text(node))
-          end
-        end
-
         private
 
         def add_wording_offense(node, message)
-          add_offense(node, location: docstring(node), message: message)
+          docstring = docstring(node)
+
+          add_offense(docstring, message: message) do |corrector|
+            next if node.heredoc?
+
+            corrector.replace(docstring, replacement_text(node))
+          end
         end
 
         def docstring(node)
-          expr = node.loc.expression
+          expr = node.source_range
 
           Parser::Source::Range.new(
             expr.source_buffer,
@@ -78,7 +107,7 @@ def docstring(node)
         def replacement_text(node)
           text = text(node)
 
-          if text =~ SHOULD_PREFIX
+          if text.match?(SHOULD_PREFIX) || text.match?(WILL_PREFIX)
             RuboCop::RSpec::Wording.new(
               text,
               ignore:  ignored_words,
@@ -97,7 +126,7 @@ def text(node)
             node.node_parts.map { |child_node| text(child_node) }.join
           when :str
             node.value
-          when :begin
+          else
             node.source
           end
         end
@@ -109,6 +138,19 @@ def custom_transform
         def ignored_words
           cop_config.fetch('IgnoredWords', [])
         end
+
+        def insufficient_docstring?(description_node)
+          insufficient_examples.include?(preprocess(text(description_node)))
+        end
+
+        def insufficient_examples
+          examples = cop_config.fetch('DisallowedExamples', [])
+          examples.map! { |example| preprocess(example) }
+        end
+
+        def preprocess(message)
+          message.strip.squeeze(' ').downcase
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb b/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb
new file mode 100644
index 000000000..c0aada43e
--- /dev/null
+++ b/lib/rubocop/cop/rspec/excessive_docstring_spacing.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for excessive whitespace in example descriptions.
+      #
+      # @example
+      #   # bad
+      #   it '  has  excessive   spacing  ' do
+      #   end
+      #
+      #   # good
+      #   it 'has excessive spacing' do
+      #   end
+      #
+      # @example
+      #   # bad
+      #   context '  when a condition   is met  ' do
+      #   end
+      #
+      #   # good
+      #   context 'when a condition is met' do
+      #   end
+      #
+      class ExcessiveDocstringSpacing < Base
+        extend AutoCorrector
+
+        MSG = 'Excessive whitespace.'
+
+        # @!method example_description(node)
+        def_node_matcher :example_description, <<~PATTERN
+          (send _ {#Examples.all #ExampleGroups.all} ${
+            $str
+            $(dstr ({str dstr `sym} ...) ...)
+          } ...)
+        PATTERN
+
+        def on_send(node)
+          example_description(node) do |description_node, message|
+            return if description_node.heredoc?
+
+            text = text(message)
+
+            return unless excessive_whitespace?(text)
+
+            add_whitespace_offense(description_node, text)
+          end
+        end
+
+        private
+
+        # @param text [String]
+        def excessive_whitespace?(text)
+          text.match?(/
+            # Leading space
+            \A[[:blank:]]
+            |
+            # Trailing space
+            [[:blank:]]\z
+            |
+            # Two or more consecutive spaces, except if they are leading spaces
+            [^[[:space:]]][[:blank:]]{2,}[^[[:blank:]]]
+          /x)
+        end
+
+        # @param text [String]
+        def strip_excessive_whitespace(text)
+          text
+            .gsub(/[[:blank:]]{2,}/, ' ')
+            .gsub(/\A[[:blank:]]|[[:blank:]]\z/, '')
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @param text [String]
+        def add_whitespace_offense(node, text)
+          docstring = docstring(node)
+          corrected = strip_excessive_whitespace(text)
+
+          add_offense(docstring) do |corrector|
+            corrector.replace(docstring, corrected)
+          end
+        end
+
+        def docstring(node)
+          expr = node.source_range
+
+          Parser::Source::Range.new(
+            expr.source_buffer,
+            expr.begin_pos + 1,
+            expr.end_pos - 1
+          )
+        end
+
+        # Recursive processing is required to process nested dstr nodes
+        # that is the case for \-separated multiline strings with interpolation.
+        def text(node)
+          case node.type
+          when :dstr
+            node.node_parts.map { |child_node| text(child_node) }.join
+          when :str, :sym
+            node.value
+          else
+            node.source
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/expect_actual.rb b/lib/rubocop/cop/rspec/expect_actual.rb
index 3bffe2179..7cef8e289 100644
--- a/lib/rubocop/cop/rspec/expect_actual.rb
+++ b/lib/rubocop/cop/rspec/expect_actual.rb
@@ -5,6 +5,8 @@ module Cop
     module RSpec
       # Checks for `expect(...)` calls containing literal values.
       #
+      # Autocorrection is performed when the expected is not a literal.
+      #
       # @example
       #   # bad
       #   expect(5).to eq(price)
@@ -16,8 +18,15 @@ module RSpec
       #   expect(pattern).to eq(/foo/)
       #   expect(name).to eq("John")
       #
-      class ExpectActual < Cop
-        MSG = 'Provide the actual you are testing to `expect(...)`.'
+      #   # bad (not supported autocorrection)
+      #   expect(false).to eq(true)
+      #
+      class ExpectActual < Base
+        extend AutoCorrector
+
+        MSG = 'Provide the actual value you are testing to `expect(...)`.'
+
+        RESTRICT_ON_SEND = Runners.all
 
         SIMPLE_LITERALS = %i[
           true
@@ -41,13 +50,15 @@ class ExpectActual < Cop
           regexp
         ].freeze
 
-        SUPPORTED_MATCHERS = %i[eq eql equal be].freeze
+        SKIPPED_MATCHERS = %i[route_to be_routable].freeze
+        CORRECTABLE_MATCHERS = %i[eq eql equal be].freeze
 
+        # @!method expect_literal(node)
         def_node_matcher :expect_literal, <<~PATTERN
           (send
             (send nil? :expect $#literal?)
-            #{Runners::ALL.node_pattern_union}
-            {
+            #Runners.all
+            ${
               (send (send nil? $:be) :== $_)
               (send nil? $_ $_ ...)
             }
@@ -55,23 +66,26 @@ class ExpectActual < Cop
         PATTERN
 
         def on_send(node)
-          expect_literal(node) do |argument|
-            add_offense(node, location: argument.source_range)
-          end
-        end
+          expect_literal(node) do |actual, send_node, matcher, expected|
+            next if SKIPPED_MATCHERS.include?(matcher)
 
-        def autocorrect(node)
-          actual, matcher, expected = expect_literal(node)
-          lambda do |corrector|
-            return unless SUPPORTED_MATCHERS.include?(matcher)
+            add_offense(actual) do |corrector|
+              next unless CORRECTABLE_MATCHERS.include?(matcher)
+              next if literal?(expected)
 
-            swap(corrector, actual, expected)
+              corrector.replace(actual, expected.source)
+              if matcher == :be
+                corrector.replace(expected, actual.source)
+              else
+                corrector.replace(send_node, "#{matcher}(#{actual.source})")
+              end
+            end
           end
         end
 
         private
 
-        # This is not implement using a NodePattern because it seems
+        # This is not implemented using a NodePattern because it seems
         # to not be able to match against an explicit (nil) sexp
         def literal?(node)
           node && (simple_literal?(node) || complex_literal?(node))
@@ -83,12 +97,7 @@ def simple_literal?(node)
 
         def complex_literal?(node)
           COMPLEX_LITERALS.include?(node.type) &&
-            node.each_child_node.all?(&method(:literal?))
-        end
-
-        def swap(corrector, actual, expected)
-          corrector.replace(actual.source_range, expected.source)
-          corrector.replace(expected.source_range, actual.source)
+            node.each_child_node.all? { |child_node| literal?(child_node) }
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/expect_change.rb b/lib/rubocop/cop/rspec/expect_change.rb
index e2afd909a..12f339e2b 100644
--- a/lib/rubocop/cop/rspec/expect_change.rb
+++ b/lib/rubocop/cop/rspec/expect_change.rb
@@ -5,19 +5,31 @@ module Cop
     module RSpec
       # Checks for consistent style of change matcher.
       #
-      # Enforces either passing object and attribute as arguments to the matcher
-      # or passing a block that reads the attribute value.
+      # Enforces either passing a receiver and message as method arguments,
+      # or a block.
       #
       # This cop can be configured using the `EnforcedStyle` option.
       #
-      # @example `EnforcedStyle: block`
-      #   # bad
-      #   expect { run }.to change(Foo, :bar)
+      # @safety
+      #   Autocorrection is unsafe because `method_call` style calls the
+      #   receiver *once* and sends the message to it before and after
+      #   calling the `expect` block, whereas `block` style calls the
+      #   expression *twice*, including the receiver.
       #
-      #   # good
-      #   expect { run }.to change { Foo.bar }
+      #   If your receiver is dynamic (e.g., the result of a method call) and
+      #   you expect it to be called before and after the `expect` block,
+      #   changing from `block` to `method_call` style may break your test.
+      #
+      #   [source,ruby]
+      #   ----
+      #   expect { run }.to change { my_method.message }
+      #   # `my_method` is called before and after `run`
       #
-      # @example `EnforcedStyle: method_call`
+      #   expect { run }.to change(my_method, :message)
+      #   # `my_method` is called once, but `message` is called on it twice
+      #   ----
+      #
+      # @example `EnforcedStyle: method_call` (default)
       #   # bad
       #   expect { run }.to change { Foo.bar }
       #   expect { run }.to change { foo.baz }
@@ -29,21 +41,38 @@ module RSpec
       #   expect { run }.to change { Foo.bar(:count) }
       #   expect { run }.to change { user.reload.name }
       #
-      class ExpectChange < Cop
+      # @example `EnforcedStyle: block`
+      #   # bad
+      #   expect { run }.to change(Foo, :bar)
+      #
+      #   # good
+      #   expect { run }.to change { Foo.bar }
+      #
+      class ExpectChange < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG_BLOCK = 'Prefer `change(%<obj>s, :%<attr>s)`.'
         MSG_CALL = 'Prefer `change { %<obj>s.%<attr>s }`.'
+        RESTRICT_ON_SEND = %i[change].freeze
 
-        def_node_matcher :expect_change_with_arguments, <<-PATTERN
-          (send nil? :change ({const send} nil? $_) (sym $_))
+        # @!method expect_change_with_arguments(node)
+        def_node_matcher :expect_change_with_arguments, <<~PATTERN
+          (send nil? :change $_ ({sym str} $_))
         PATTERN
 
-        def_node_matcher :expect_change_with_block, <<-PATTERN
+        # @!method expect_change_with_block(node)
+        def_node_matcher :expect_change_with_block, <<~PATTERN
           (block
             (send nil? :change)
             (args)
-            (send ({const send} nil? $_) $_)
+            (send
+              ${
+                (send nil? _)  # change { user.name }
+                const          # change { User.count }
+              }
+              $_
+            )
           )
         PATTERN
 
@@ -51,48 +80,22 @@ def on_send(node)
           return unless style == :block
 
           expect_change_with_arguments(node) do |receiver, message|
-            add_offense(
-              node,
-              message: format(MSG_CALL, obj: receiver, attr: message)
-            )
+            msg = format(MSG_CALL, obj: receiver.source, attr: message)
+            add_offense(node, message: msg) do |corrector|
+              replacement = "change { #{receiver.source}.#{message} }"
+              corrector.replace(node, replacement)
+            end
           end
         end
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless style == :method_call
 
           expect_change_with_block(node) do |receiver, message|
-            add_offense(
-              node,
-              message: format(MSG_BLOCK, obj: receiver, attr: message)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          if style == :block
-            autocorrect_method_call_to_block(node)
-          else
-            autocorrect_block_to_method_call(node)
-          end
-        end
-
-        private
-
-        def autocorrect_method_call_to_block(node)
-          lambda do |corrector|
-            expect_change_with_arguments(node) do |receiver, message|
-              replacement = "change { #{receiver}.#{message} }"
-              corrector.replace(node.loc.expression, replacement)
-            end
-          end
-        end
-
-        def autocorrect_block_to_method_call(node)
-          lambda do |corrector|
-            expect_change_with_block(node) do |receiver, message|
-              replacement = "change(#{receiver}, :#{message})"
-              corrector.replace(node.loc.expression, replacement)
+            msg = format(MSG_BLOCK, obj: receiver.source, attr: message)
+            add_offense(node, message: msg) do |corrector|
+              replacement = "change(#{receiver.source}, :#{message})"
+              corrector.replace(node, replacement)
             end
           end
         end
diff --git a/lib/rubocop/cop/rspec/expect_in_hook.rb b/lib/rubocop/cop/rspec/expect_in_hook.rb
index b0cd8e69b..4474c707b 100644
--- a/lib/rubocop/cop/rspec/expect_in_hook.rb
+++ b/lib/rubocop/cop/rspec/expect_in_hook.rb
@@ -20,21 +20,25 @@ module RSpec
       #   it do
       #     expect(something).to eq 'foo'
       #   end
-      class ExpectInHook < Cop
+      #
+      class ExpectInHook < Base
         MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'
 
-        def_node_search :expectation, Expectations::ALL.send_pattern
+        # @!method expectation(node)
+        def_node_search :expectation, '(send nil? #Expectations.all ...)'
 
         def on_block(node)
           return unless hook?(node)
           return if node.body.nil?
 
           expectation(node.body) do |expect|
-            add_offense(expect, location: :selector,
-                                message: message(expect, node))
+            add_offense(expect.loc.selector,
+                        message: message(expect, node))
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def message(expect, hook)
diff --git a/lib/rubocop/cop/rspec/expect_in_let.rb b/lib/rubocop/cop/rspec/expect_in_let.rb
new file mode 100644
index 000000000..d74e4a65a
--- /dev/null
+++ b/lib/rubocop/cop/rspec/expect_in_let.rb
@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not use `expect` in let.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) do
+      #     expect(something).to eq 'foo'
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect(something).to eq 'foo'
+      #   end
+      #
+      class ExpectInLet < Base
+        MSG = 'Do not use `%<expect>s` in let'
+
+        # @!method expectation(node)
+        def_node_search :expectation, '(send nil? #Expectations.all ...)'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless let?(node)
+          return if node.body.nil?
+
+          expectation(node.body) do |expect|
+            add_offense(expect.loc.selector, message: message(expect))
+          end
+        end
+
+        private
+
+        def message(expect)
+          format(MSG, expect: expect.method_name)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/expect_output.rb b/lib/rubocop/cop/rspec/expect_output.rb
index 9d2e37153..7a0ff63dd 100644
--- a/lib/rubocop/cop/rspec/expect_output.rb
+++ b/lib/rubocop/cop/rspec/expect_output.rb
@@ -14,20 +14,18 @@ module RSpec
       #
       #   # good
       #   expect { my_app.print_report }.to output('Hello World').to_stdout
-      class ExpectOutput < Cop
-        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` '\
+      #
+      class ExpectOutput < Base
+        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` ' \
               'instead of mutating $%<name>s.'
 
         def on_gvasgn(node)
           return unless inside_example_scope?(node)
 
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          variable_name, _rhs = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
-          name = variable_name[1..-1]
+          name = node.name[1..]
           return unless name.eql?('stdout') || name.eql?('stderr')
 
-          add_offense(node, location: :name, message: format(MSG, name: name))
+          add_offense(node.loc.name, message: format(MSG, name: name))
         end
 
         private
diff --git a/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb b/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb
deleted file mode 100644
index 863eb401f..000000000
--- a/lib/rubocop/cop/rspec/factory_bot/attribute_defined_statically.rb
+++ /dev/null
@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Always declare attribute values as blocks.
-        #
-        # @example
-        #   # bad
-        #   kind [:active, :rejected].sample
-        #
-        #   # good
-        #   kind { [:active, :rejected].sample }
-        #
-        #   # bad
-        #   closed_at 1.day.from_now
-        #
-        #   # good
-        #   closed_at { 1.day.from_now }
-        #
-        #   # bad
-        #   count 1
-        #
-        #   # good
-        #   count { 1 }
-        class AttributeDefinedStatically < Cop
-          MSG = 'Use a block to declare attribute values.'
-
-          def_node_matcher :value_matcher, <<-PATTERN
-            (send _ !#reserved_method? $...)
-          PATTERN
-
-          def_node_search :factory_attributes, <<-PATTERN
-            (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
-          PATTERN
-
-          def on_block(node)
-            factory_attributes(node).to_a.flatten.each do |attribute|
-              next unless offensive_receiver?(attribute.receiver, node)
-              next if proc?(attribute) || association?(attribute.first_argument)
-
-              add_offense(attribute)
-            end
-          end
-
-          def autocorrect(node)
-            if node.parenthesized?
-              autocorrect_replacing_parens(node)
-            else
-              autocorrect_without_parens(node)
-            end
-          end
-
-          private
-
-          def offensive_receiver?(receiver, node)
-            receiver.nil? ||
-              receiver.self_type? ||
-              receiver_matches_first_block_argument?(receiver, node)
-          end
-
-          def receiver_matches_first_block_argument?(receiver, node)
-            first_block_argument = node.arguments.first
-
-            !first_block_argument.nil? &&
-              receiver.lvar_type? &&
-              receiver.node_parts == first_block_argument.node_parts
-          end
-
-          def proc?(attribute)
-            value_matcher(attribute).to_a.all?(&:block_pass_type?)
-          end
-
-          def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
-
-          def autocorrect_replacing_parens(node)
-            left_braces, right_braces = braces(node)
-
-            lambda do |corrector|
-              corrector.replace(node.location.begin, ' ' + left_braces)
-              corrector.replace(node.location.end, right_braces)
-            end
-          end
-
-          def autocorrect_without_parens(node)
-            left_braces, right_braces = braces(node)
-
-            lambda do |corrector|
-              argument = node.first_argument
-              expression = argument.location.expression
-              corrector.insert_before(expression, left_braces)
-              corrector.insert_after(expression, right_braces)
-            end
-          end
-
-          def braces(node)
-            if value_hash_without_braces?(node.first_argument)
-              ['{ { ', ' } }']
-            else
-              ['{ ', ' }']
-            end
-          end
-
-          def value_hash_without_braces?(node)
-            node.hash_type? && !node.braces?
-          end
-
-          def reserved_method?(method_name)
-            RuboCop::RSpec::FactoryBot.reserved_methods.include?(method_name)
-          end
-
-          def attribute_defining_method?(method_name)
-            RuboCop::RSpec::FactoryBot.attribute_defining_methods
-              .include?(method_name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/factory_bot/create_list.rb b/lib/rubocop/cop/rspec/factory_bot/create_list.rb
deleted file mode 100644
index 11addc723..000000000
--- a/lib/rubocop/cop/rspec/factory_bot/create_list.rb
+++ /dev/null
@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Checks for create_list usage.
-        #
-        # This cop can be configured using the `EnforcedStyle` option
-        #
-        # @example `EnforcedStyle: create_list`
-        #   # bad
-        #   3.times { create :user }
-        #
-        #   # good
-        #   create_list :user, 3
-        #
-        #   # good
-        #   3.times { |n| create :user, created_at: n.months.ago }
-        #
-        # @example `EnforcedStyle: n_times`
-        #   # bad
-        #   create_list :user, 3
-        #
-        #   # good
-        #   3.times { create :user }
-        class CreateList < Cop
-          include ConfigurableEnforcedStyle
-
-          MSG_CREATE_LIST = 'Prefer create_list.'
-          MSG_N_TIMES = 'Prefer %<number>s.times.'
-
-          def_node_matcher :n_times_block_without_arg?, <<-PATTERN
-            (block
-              (send (int _) :times)
-              (args)
-              ...
-            )
-          PATTERN
-
-          def_node_matcher :factory_call, <<-PATTERN
-            (send ${(const nil? {:FactoryGirl :FactoryBot}) nil?} :create (sym $_) $...)
-          PATTERN
-
-          def_node_matcher :factory_list_call, <<-PATTERN
-            (send ${(const nil? {:FactoryGirl :FactoryBot}) nil?} :create_list (sym $_) (int $_) $...)
-          PATTERN
-
-          def on_block(node)
-            return unless style == :create_list
-            return unless n_times_block_without_arg?(node)
-            return unless contains_only_factory?(node.body)
-
-            add_offense(node.send_node, message: MSG_CREATE_LIST)
-          end
-
-          def on_send(node)
-            return unless style == :n_times
-
-            factory_list_call(node) do |_receiver, _factory, count, _|
-              add_offense(
-                node,
-                location: :selector,
-                message: format(MSG_N_TIMES, number: count)
-              )
-            end
-          end
-
-          def autocorrect(node)
-            if style == :create_list
-              CreateListCorrector.new(node)
-            else
-              TimesCorrector.new(node)
-            end
-          end
-
-          private
-
-          def contains_only_factory?(node)
-            if node.block_type?
-              factory_call(node.send_node)
-            else
-              factory_call(node)
-            end
-          end
-
-          # :nodoc
-          class Corrector
-            private
-
-            def build_options_string(options)
-              options.map(&:source).join(', ')
-            end
-
-            def format_method_call(node, method, arguments)
-              if node.block_type? || node.parenthesized?
-                "#{method}(#{arguments})"
-              else
-                "#{method} #{arguments}"
-              end
-            end
-
-            def format_receiver(receiver)
-              return '' unless receiver
-
-              "#{receiver.source}."
-            end
-          end
-
-          # :nodoc
-          class TimesCorrector < Corrector
-            def initialize(node)
-              @node = node
-            end
-
-            def call(corrector)
-              replacement = generate_n_times_block(node)
-              corrector.replace(node.loc.expression, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def generate_n_times_block(node)
-              factory, count, *options = node.arguments
-
-              arguments = factory.source
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(node.receiver)
-              replacement += format_method_call(node, 'create', arguments)
-              "#{count.source}.times { #{replacement} }"
-            end
-          end
-
-          # :nodoc:
-          class CreateListCorrector < Corrector
-            def initialize(node)
-              @node = node.parent
-            end
-
-            def call(corrector)
-              replacement = if node.body.block_type?
-                              call_with_block_replacement(node)
-                            else
-                              call_replacement(node)
-                            end
-
-              corrector.replace(node.loc.expression, replacement)
-            end
-
-            private
-
-            attr_reader :node
-
-            def call_with_block_replacement(node)
-              block = node.body
-              arguments = build_arguments(block, node.receiver.source)
-              replacement = format_receiver(block.send_node.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement += format_block(block)
-              replacement
-            end
-
-            def build_arguments(node, count)
-              factory, *options = *node.send_node.arguments
-
-              arguments = ":#{factory.value}, #{count}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-              arguments
-            end
-
-            def call_replacement(node)
-              block = node.body
-              factory, *options = *block.arguments
-
-              arguments = "#{factory.source}, #{node.receiver.source}"
-              options = build_options_string(options)
-              arguments += ", #{options}" unless options.empty?
-
-              replacement = format_receiver(block.receiver)
-              replacement += format_method_call(block, 'create_list', arguments)
-              replacement
-            end
-
-            def format_block(node)
-              if node.body.begin_type?
-                format_multiline_block(node)
-              else
-                format_singeline_block(node)
-              end
-            end
-
-            def format_multiline_block(node)
-              indent = ' ' * node.body.loc.column
-              indent_end = ' ' * node.parent.loc.column
-              " do #{node.arguments.source}\n" \
-              "#{indent}#{node.body.source}\n" \
-              "#{indent_end}end"
-            end
-
-            def format_singeline_block(node)
-              " { #{node.arguments.source} #{node.body.source} }"
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb b/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb
deleted file mode 100644
index 3a49f33d9..000000000
--- a/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      module FactoryBot
-        # Use string value when setting the class attribute explicitly.
-        #
-        # This cop would promote faster tests by lazy-loading of
-        # application files. Also, this could help you suppress potential bugs
-        # in combination with external libraries by avoiding a preload of
-        # application files from the factory files.
-        #
-        # @example
-        #   # bad
-        #   factory :foo, class: Foo do
-        #   end
-        #
-        #   # good
-        #   factory :foo, class: 'Foo' do
-        #   end
-        class FactoryClassName < Cop
-          MSG = "Pass '%<class_name>s' string instead of `%<class_name>s` " \
-                'constant.'
-          ALLOWED_CONSTANTS = %w[Hash OpenStruct].freeze
-
-          def_node_matcher :class_name, <<~PATTERN
-            (send _ :factory _ (hash <(pair (sym :class) $(const ...)) ...>))
-          PATTERN
-
-          def on_send(node)
-            class_name(node) do |cn|
-              next if allowed?(cn.const_name)
-
-              add_offense(cn, message: format(MSG, class_name: cn.const_name))
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "'#{node.source}'")
-            end
-          end
-
-          private
-
-          def allowed?(const_name)
-            ALLOWED_CONSTANTS.include?(const_name)
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/file_path.rb b/lib/rubocop/cop/rspec/file_path.rb
deleted file mode 100644
index b4d81df62..000000000
--- a/lib/rubocop/cop/rspec/file_path.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks that spec file paths are consistent with the test subject.
-      #
-      # Checks the path of the spec file and enforces that it reflects the
-      # described class/module and its optionally called out method.
-      #
-      # With the configuration option `IgnoreMethods` the called out method will
-      # be ignored when determining the enforced path.
-      #
-      # With the configuration option `CustomTransform` modules or classes can
-      # be specified that should not as usual be transformed from CamelCase to
-      # snake_case (e.g. 'RuboCop' => 'rubocop' ).
-      #
-      # @example
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # bad
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_method_spec.rb  # describe MyClass, '#method'
-      #
-      #   # good
-      #   my_class/method_spec.rb  # describe MyClass, '#method'
-      #
-      # @example when configuration is `IgnoreMethods: true`
-      #   # bad
-      #   whatever_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass
-      #
-      #   # good
-      #   my_class_spec.rb         # describe MyClass, '#method'
-      #
-      class FilePath < Cop
-        include RuboCop::RSpec::TopLevelDescribe
-
-        MSG = 'Spec path should end with `%<suffix>s`.'
-
-        def_node_search :const_described?,  '(send _ :describe (const ...) ...)'
-        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
-
-        def on_top_level_describe(node, args)
-          return unless const_described?(node) && single_top_level_describe?
-          return if routing_spec?(args)
-
-          glob = glob_for(args)
-
-          return if filename_ends_with?(glob)
-
-          add_offense(
-            node,
-            message: format(MSG, suffix: glob)
-          )
-        end
-
-        private
-
-        def routing_spec?(args)
-          args.any?(&method(:routing_metadata?))
-        end
-
-        def glob_for((described_class, method_name))
-          "#{expected_path(described_class)}#{name_glob(method_name)}*_spec.rb"
-        end
-
-        def name_glob(name)
-          return unless name&.str_type?
-
-          "*#{name.str_content.gsub(/\W/, '')}" unless ignore_methods?
-        end
-
-        def expected_path(constant)
-          File.join(
-            constant.const_name.split('::').map do |name|
-              custom_transform.fetch(name) { camel_to_snake_case(name) }
-            end
-          )
-        end
-
-        def camel_to_snake_case(string)
-          string
-            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
-            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
-            .downcase
-        end
-
-        def custom_transform
-          cop_config.fetch('CustomTransform', {})
-        end
-
-        def ignore_methods?
-          cop_config['IgnoreMethods']
-        end
-
-        def filename_ends_with?(glob)
-          File.fnmatch?("*#{glob}", processed_source.buffer.name)
-        end
-
-        def relevant_rubocop_rspec_file?(_file)
-          true
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/focus.rb b/lib/rubocop/cop/rspec/focus.rb
index 11413d4e5..5d247490b 100644
--- a/lib/rubocop/cop/rspec/focus.rb
+++ b/lib/rubocop/cop/rspec/focus.rb
@@ -5,6 +5,8 @@ module Cop
     module RSpec
       # Checks if examples are focused.
       #
+      # This cop does not support autocorrection in some cases.
+      #
       # @example
       #   # bad
       #   describe MyClass, focus: true do
@@ -19,39 +21,99 @@ module RSpec
       #   # good
       #   describe MyClass do
       #   end
-      class Focus < Cop
-        MSG = 'Focused spec found.'
-
-        focusable =
-          ExampleGroups::GROUPS  +
-          ExampleGroups::SKIPPED +
-          Examples::EXAMPLES     +
-          Examples::SKIPPED      +
-          Examples::PENDING
+      #
+      #   # bad
+      #   fdescribe 'test' do; end
+      #
+      #   # good
+      #   describe 'test' do; end
+      #
+      #   # bad
+      #   shared_examples 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_examples 'test' do; end
+      #
+      #   # bad
+      #   shared_context 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_context 'test' do; end
+      #
+      #   # bad (does not support autocorrection)
+      #   focus 'test' do; end
+      #
+      class Focus < Base
+        extend AutoCorrector
+        include RangeHelp
 
-        focused = ExampleGroups::FOCUSED + Examples::FOCUSED
+        MSG = 'Focused spec found.'
 
-        FOCUSABLE_SELECTORS = focusable.node_pattern_union
+        # @!method focusable_selector?(node)
+        def_node_matcher :focusable_selector?, <<~PATTERN
+          {
+            #ExampleGroups.regular
+            #ExampleGroups.skipped
+            #Examples.regular
+            #Examples.skipped
+            #Examples.pending
+            #SharedGroups.all
+          }
+        PATTERN
 
-        def_node_matcher :metadata, <<-PATTERN
-          {(send #{RSPEC} #{FOCUSABLE_SELECTORS} <$(sym :focus) ...>)
-           (send #{RSPEC} #{FOCUSABLE_SELECTORS} ... (hash <$(pair (sym :focus) true) ...>))}
+        # @!method metadata(node)
+        def_node_matcher :metadata, <<~PATTERN
+          {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
+           (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
-        def_node_matcher :focused_block?, focused.send_pattern
+        # @!method focused_block?(node)
+        def_node_matcher :focused_block?, <<~PATTERN
+          (send #rspec? {#ExampleGroups.focused #Examples.focused} ...)
+        PATTERN
 
         def on_send(node)
-          focus_metadata(node) do |focus|
-            add_offense(focus)
+          return if node.chained? || node.each_ancestor(:any_def).any?
+
+          if focused_block?(node)
+            on_focused_block(node)
+          else
+            metadata(node) do |focus|
+              on_metadata(focus)
+            end
           end
         end
 
         private
 
-        def focus_metadata(node, &block)
-          yield(node) if focused_block?(node)
+        def on_focused_block(node)
+          add_offense(node) do |corrector|
+            correct_send(corrector, node)
+          end
+        end
+
+        def on_metadata(node)
+          add_offense(node) do |corrector|
+            corrector.remove(with_surrounding(node))
+          end
+        end
+
+        def with_surrounding(focus)
+          range_with_space =
+            range_with_surrounding_space(focus.source_range, side: :left)
+
+          range_with_surrounding_comma(range_with_space, :left)
+        end
+
+        def correct_send(corrector, focus)
+          range = focus.loc.selector
+          unfocused = focus.method_name.to_s.sub(/^f/, '')
+          unless Examples.regular(unfocused) || ExampleGroups.regular(unfocused)
+            return
+          end
 
-          metadata(node, &block)
+          corrector.replace(range,
+                            range.source.sub(focus.method_name.to_s, unfocused))
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/hook_argument.rb b/lib/rubocop/cop/rspec/hook_argument.rb
index 99411cd90..654dd036f 100644
--- a/lib/rubocop/cop/rspec/hook_argument.rb
+++ b/lib/rubocop/cop/rspec/hook_argument.rb
@@ -10,7 +10,7 @@ module RSpec
       # styles: "implicit", "each", and "example." All styles have
       # the same behavior.
       #
-      # @example when configuration is `EnforcedStyle: implicit`
+      # @example `EnforcedStyle: implicit` (default)
       #   # bad
       #   before(:each) do
       #     # ...
@@ -26,13 +26,13 @@ module RSpec
       #     # ...
       #   end
       #
-      # @example when configuration is `EnforcedStyle: each`
+      # @example `EnforcedStyle: each`
       #   # bad
       #   before(:example) do
       #     # ...
       #   end
       #
-      #   # good
+      #   # bad
       #   before do
       #     # ...
       #   end
@@ -42,7 +42,7 @@ module RSpec
       #     # ...
       #   end
       #
-      # @example when configuration is `EnforcedStyle: example`
+      # @example `EnforcedStyle: example`
       #   # bad
       #   before(:each) do
       #     # ...
@@ -57,20 +57,23 @@ module RSpec
       #   before(:example) do
       #     # ...
       #   end
-      class HookArgument < Cop
+      #
+      class HookArgument < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        IMPLICIT_MSG = 'Omit the default `%<scope>p` ' \
-                       'argument for RSpec hooks.'
+        IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
-        HOOKS = Hooks::ALL.node_pattern_union.freeze
-
-        def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send _ #{HOOKS} (sym ${:each :example})) ...)
+        # @!method scoped_hook(node)
+        def_node_matcher :scoped_hook, <<~PATTERN
+          (any_block $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, "(block $(send _ #{HOOKS}) ...)"
+        # @!method unscoped_hook(node)
+        def_node_matcher :unscoped_hook, <<~PATTERN
+          (any_block $(send _ #Hooks.all) ...)
+        PATTERN
 
         def on_block(node)
           hook(node) do |method_send, scope_name|
@@ -78,32 +81,36 @@ def on_block(node)
             return check_implicit(method_send) unless scope_name
 
             style_detected(scope_name)
-            add_offense(
-              method_send,
-              message: explicit_message(scope_name)
-            )
+            msg = explicit_message(scope_name)
+            add_offense(method_send, message: msg) do |corrector|
+              autocorrect(corrector, node, method_send)
+            end
           end
         end
 
-        def autocorrect(node)
-          scope = implicit_style? ? '' : "(#{style.inspect})"
-
-          lambda do |corrector|
-            corrector.replace(argument_range(node), scope)
-          end
-        end
+        alias on_numblock on_block
 
         private
 
+        def autocorrect(corrector, _node, method_send)
+          scope = implicit_style? ? '' : "(#{style.inspect})"
+          corrector.replace(
+            LocationHelp.arguments_with_whitespace(method_send), scope
+          )
+        end
+
         def check_implicit(method_send)
           style_detected(:implicit)
           return if implicit_style?
 
-          add_offense(
-            method_send,
-            location: :selector,
-            message: format(EXPLICIT_MSG, scope: style)
-          )
+          msg = explicit_message(nil)
+          add_offense(method_send.loc.selector, message: msg) do |corrector|
+            scope = "(#{style.inspect})"
+            corrector.replace(
+              LocationHelp.arguments_with_whitespace(method_send),
+              scope
+            )
+          end
         end
 
         def explicit_message(scope)
@@ -121,12 +128,6 @@ def implicit_style?
         def hook(node, &block)
           scoped_hook(node, &block) || unscoped_hook(node, &block)
         end
-
-        def argument_range(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/hooks_before_examples.rb b/lib/rubocop/cop/rspec/hooks_before_examples.rb
index 0d4b94500..e8aeeebb5 100644
--- a/lib/rubocop/cop/rspec/hooks_before_examples.rb
+++ b/lib/rubocop/cop/rspec/hooks_before_examples.rb
@@ -6,8 +6,7 @@ module RSpec
       # Checks for before/around/after hooks that come after an example.
       #
       # @example
-      #   # Bad
-      #
+      #   # bad
       #   it 'checks what foo does' do
       #     expect(foo).to be
       #   end
@@ -15,7 +14,7 @@ module RSpec
       #   before { prepare }
       #   after { clean_up }
       #
-      #   # Good
+      #   # good
       #   before { prepare }
       #   after { clean_up }
       #
@@ -23,16 +22,19 @@ module RSpec
       #     expect(foo).to be
       #   end
       #
-      class HooksBeforeExamples < Cop
-        include RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
+      class HooksBeforeExamples < Base
+        extend AutoCorrector
 
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
-        def_node_matcher :example_or_group?, <<-PATTERN
+        # @!method example_or_group?(node)
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
-            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
-            #{Includes::EXAMPLES.send_pattern}
+            (any_block {
+              (send #rspec? #ExampleGroups.all ...)
+              (send nil? #Examples.all ...)
+            } ...)
+            (send nil? #Includes.examples ...)
           }
         PATTERN
 
@@ -42,16 +44,7 @@ def on_block(node)
           check_hooks(node.body) if multiline_block?(node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_example = find_first_example(node.parent)
-            first_example_pos = first_example.loc.expression
-            indent = "\n" + ' ' * first_example.loc.column
-
-            corrector.insert_before(first_example_pos, source(node) + indent)
-            corrector.remove(node_range_with_surrounding_space(node))
-          end
-        end
+        alias on_numblock on_block
 
         private
 
@@ -63,14 +56,13 @@ def check_hooks(node)
           first_example = find_first_example(node)
           return unless first_example
 
-          node.each_child_node do |child|
-            next if child.sibling_index < first_example.sibling_index
-            next unless hook?(child)
+          first_example.right_siblings.each do |sibling|
+            next unless hook?(sibling)
 
-            add_offense(
-              child,
-              message: format(MSG, hook: child.method_name)
-            )
+            msg = format(MSG, hook: sibling.method_name)
+            add_offense(sibling, message: msg) do |corrector|
+              autocorrect(corrector, sibling, first_example)
+            end
           end
         end
 
@@ -78,17 +70,10 @@ def find_first_example(node)
           node.children.find { |sibling| example_or_group?(sibling) }
         end
 
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          node.loc.expression.with(end_pos: final_end_location(node).end_pos)
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/identical_equality_assertion.rb b/lib/rubocop/cop/rspec/identical_equality_assertion.rb
new file mode 100644
index 000000000..7298415c9
--- /dev/null
+++ b/lib/rubocop/cop/rspec/identical_equality_assertion.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for equality assertions with identical expressions on both sides.
+      #
+      # @example
+      #   # bad
+      #   expect(foo.bar).to eq(foo.bar)
+      #   expect(foo.bar).to eql(foo.bar)
+      #
+      #   # good
+      #   expect(foo.bar).to eq(2)
+      #   expect(foo.bar).to eql(2)
+      #
+      class IdenticalEqualityAssertion < Base
+        MSG = 'Identical expressions on both sides of the equality ' \
+              'may indicate a flawed test.'
+        RESTRICT_ON_SEND = %i[to].freeze
+
+        # @!method equality_check?(node)
+        def_node_matcher :equality_check?, <<~PATTERN
+          (send (send nil? :expect $_) :to
+            {(send nil? {:eql :eq :be} $_)
+             (send (send nil? :be) :== $_)})
+        PATTERN
+
+        def on_send(node)
+          equality_check?(node) do |left, right|
+            add_offense(node) if left == right
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/implicit_block_expectation.rb b/lib/rubocop/cop/rspec/implicit_block_expectation.rb
index d77680029..55a00fc61 100644
--- a/lib/rubocop/cop/rspec/implicit_block_expectation.rb
+++ b/lib/rubocop/cop/rspec/implicit_block_expectation.rb
@@ -16,20 +16,24 @@ module RSpec
       #   it 'changes something to a new value' do
       #     expect { do_something }.to change(something).to(new_value)
       #   end
-      class ImplicitBlockExpectation < Cop
+      #
+      class ImplicitBlockExpectation < Base
         MSG = 'Avoid implicit block expectations.'
+        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
 
-        def_node_matcher :lambda?, <<-PATTERN
+        # @!method lambda?(node)
+        def_node_matcher :lambda?, <<~PATTERN
           {
             (send (const nil? :Proc) :new)
-            (send nil? :proc)
-            (send nil? :lambda)
+            (send nil? {:proc :lambda})
           }
         PATTERN
 
+        # @!method lambda_subject?(node)
         def_node_matcher :lambda_subject?, '(block #lambda? ...)'
 
-        def_node_matcher :implicit_expect, <<-PATTERN
+        # @!method implicit_expect(node)
+        def_node_matcher :implicit_expect, <<~PATTERN
           $(send nil? {:is_expected :should :should_not} ...)
         PATTERN
 
diff --git a/lib/rubocop/cop/rspec/implicit_expect.rb b/lib/rubocop/cop/rspec/implicit_expect.rb
index ca3184bf8..1c46715df 100644
--- a/lib/rubocop/cop/rspec/implicit_expect.rb
+++ b/lib/rubocop/cop/rspec/implicit_expect.rb
@@ -8,8 +8,7 @@ module RSpec
       # This cop can be configured using the `EnforcedStyle` option
       # and supports the `--auto-gen-config` flag.
       #
-      # @example `EnforcedStyle: is_expected`
-      #
+      # @example `EnforcedStyle: is_expected` (default)
       #   # bad
       #   it { should be_truthy }
       #
@@ -17,22 +16,25 @@ module RSpec
       #   it { is_expected.to be_truthy }
       #
       # @example `EnforcedStyle: should`
-      #
       #   # bad
       #   it { is_expected.to be_truthy }
       #
       #   # good
       #   it { should be_truthy }
       #
-      class ImplicitExpect < Cop
+      class ImplicitExpect < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<good>s` over `%<bad>s`.'
 
-        def_node_matcher :implicit_expect, <<-PATTERN
+        RESTRICT_ON_SEND = Runners.all + %i[should should_not]
+
+        # @!method implicit_expect(node)
+        def_node_matcher :implicit_expect, <<~PATTERN
           {
             (send nil? ${:should :should_not} ...)
-            (send (send nil? $:is_expected) #{Runners::ALL.node_pattern_union} ...)
+            (send (send nil? $:is_expected) #Runners.all ...)
           }
         PATTERN
 
@@ -44,7 +46,7 @@ class ImplicitExpect < Cop
 
         ENFORCED_REPLACEMENTS = alternatives.merge(alternatives.invert).freeze
 
-        def on_send(node) # rubocop:disable Metrics/MethodLength
+        def on_send(node)
           return unless (source_range = offending_expect(node))
 
           expectation_source = source_range.source
@@ -54,20 +56,11 @@ def on_send(node) # rubocop:disable Metrics/MethodLength
           else
             opposite_style_detected
 
-            add_offense(
-              node,
-              location: source_range,
-              message: offense_message(expectation_source)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            offense     = offending_expect(node)
-            replacement = replacement_source(offense.source)
-
-            corrector.replace(offense, replacement)
+            msg = offense_message(expectation_source)
+            add_offense(source_range, message: msg) do |corrector|
+              replacement = replacement_source(expectation_source)
+              corrector.replace(source_range, replacement)
+            end
           end
         end
 
@@ -76,13 +69,13 @@ def autocorrect(node)
         def offending_expect(node)
           case implicit_expect(node)
           when :is_expected
-            is_expected_range(node.loc)
+            range_for_is_expected(node.loc)
           when :should, :should_not
             node.loc.selector
           end
         end
 
-        def is_expected_range(source_map) # rubocop:disable Naming/PredicateName
+        def range_for_is_expected(source_map)
           Parser::Source::Range.new(
             source_map.expression.source_buffer,
             source_map.expression.begin_pos,
diff --git a/lib/rubocop/cop/rspec/implicit_subject.rb b/lib/rubocop/cop/rspec/implicit_subject.rb
index b3deba158..f9395ab1e 100644
--- a/lib/rubocop/cop/rspec/implicit_subject.rb
+++ b/lib/rubocop/cop/rspec/implicit_subject.rb
@@ -7,7 +7,7 @@ module RSpec
       #
       # This cop can be configured using the `EnforcedStyle` option
       #
-      # @example `EnforcedStyle: single_line_only`
+      # @example `EnforcedStyle: single_line_only` (default)
       #   # bad
       #   it do
       #     is_expected.to be_truthy
@@ -19,6 +19,22 @@ module RSpec
       #     expect(subject).to be_truthy
       #   end
       #
+      # @example `EnforcedStyle: single_statement_only`
+      #   # bad
+      #   it do
+      #     foo = 1
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it do
+      #     foo = 1
+      #     expect(subject).to be_truthy
+      #   end
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
       # @example `EnforcedStyle: disallow`
       #   # bad
       #   it { is_expected.to be_truthy }
@@ -26,49 +42,131 @@ module RSpec
       #   # good
       #   it { expect(subject).to be_truthy }
       #
-      class ImplicitSubject < Cop
+      # @example `EnforcedStyle: require_implicit`
+      #   # bad
+      #   it { expect(subject).to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # bad
+      #   it do
+      #     expect(subject).to be_truthy
+      #   end
+      #
+      #   # good
+      #   it do
+      #     is_expected.to be_truthy
+      #   end
+      #
+      #   # good
+      #   it { expect(named_subject).to be_truthy }
+      #
+      class ImplicitSubject < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG = "Don't use implicit subject."
+        MSG_REQUIRE_EXPLICIT = "Don't use implicit subject."
+
+        MSG_REQUIRE_IMPLICIT = "Don't use explicit subject."
+
+        RESTRICT_ON_SEND = %i[
+          expect
+          is_expected
+          should
+          should_not
+        ].freeze
+
+        # @!method explicit_unnamed_subject?(node)
+        def_node_matcher :explicit_unnamed_subject?, <<~PATTERN
+          (send nil? :expect (send nil? :subject))
+        PATTERN
 
-        def_node_matcher :implicit_subject?, <<-PATTERN
+        # @!method implicit_subject?(node)
+        def_node_matcher :implicit_subject?, <<~PATTERN
           (send nil? {:should :should_not :is_expected} ...)
         PATTERN
 
         def on_send(node)
-          return unless implicit_subject?(node)
-          return if valid_usage?(node)
+          return unless invalid?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          case node.method_name
+          when :expect
+            corrector.replace(node, 'is_expected')
+          when :is_expected
+            corrector.replace(node.location.selector, 'expect(subject)')
+          when :should
+            corrector.replace(node.location.selector, 'expect(subject).to')
+          when :should_not
+            corrector.replace(node.location.selector, 'expect(subject).not_to')
+          else
+            # :nocov:
+            :noop
+            # :nocov:
+          end
+        end
 
-          add_offense(node)
+        def message(_node)
+          case style
+          when :require_implicit
+            MSG_REQUIRE_IMPLICIT
+          else
+            MSG_REQUIRE_EXPLICIT
+          end
         end
 
-        def autocorrect(node)
-          replacement = 'expect(subject)'
-          if node.method_name == :should
-            replacement += '.to'
-          elsif node.method_name == :should_not
-            replacement += '.not_to'
+        def invalid?(node)
+          case style
+          when :require_implicit
+            explicit_unnamed_subject?(node)
+          when :disallow
+            implicit_subject_in_non_its?(node)
+          when :single_line_only
+            implicit_subject_in_non_its_and_non_single_line?(node)
+          when :single_statement_only
+            implicit_subject_in_non_its_and_non_single_statement?(node)
+          else
+            # :nocov:
+            :noop
+            # :nocov:
           end
+        end
 
-          ->(corrector) { corrector.replace(node.loc.selector, replacement) }
+        def implicit_subject_in_non_its?(node)
+          implicit_subject?(node) && !its?(node)
         end
 
-        private
+        def implicit_subject_in_non_its_and_non_single_line?(node)
+          implicit_subject_in_non_its?(node) && !single_line?(node)
+        end
 
-        def valid_usage?(node)
-          example = node.ancestors.find { |parent| example?(parent) }
-          return false if example.nil?
+        def implicit_subject_in_non_its_and_non_single_statement?(node)
+          implicit_subject_in_non_its?(node) && !single_statement?(node)
+        end
 
-          example.method_name == :its || allowed_by_style?(example)
+        def its?(node)
+          example_of(node)&.method?(:its)
         end
 
-        def allowed_by_style?(example)
-          if style == :single_line_only
-            example.single_line?
-          elsif style == :single_statement_only
-            !example.body.begin_type?
-          else
-            false
+        def single_line?(node)
+          example_of(node)&.single_line?
+        end
+
+        def single_statement?(node)
+          !example_of(node)&.body&.begin_type?
+        end
+
+        def example_of(node)
+          node.each_ancestor.find do |ancestor|
+            example?(ancestor)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/include_examples.rb b/lib/rubocop/cop/rspec/include_examples.rb
new file mode 100644
index 000000000..81b44ccf3
--- /dev/null
+++ b/lib/rubocop/cop/rspec/include_examples.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for usage of `include_examples`.
+      #
+      # `include_examples`, unlike `it_behaves_like`, does not create its
+      # own context. As such, using `subject`, `let`, `before`/`after`, etc.
+      # within shared examples included with `include_examples` can have
+      # unexpected behavior and side effects.
+      #
+      # Prefer using `it_behaves_like` instead.
+      #
+      # @safety
+      #   `include_examples` and `it_behaves_like` have different scoping
+      #   behaviors.
+      #   Changing `include_examples` to `it_behaves_like` creates a new
+      #   context, altering setup dependencies, which can lead to unexpected
+      #   test failures.
+      #   Specifically, the scope of hooks (`before`, `after`, `around`)
+      #   changes, which may prevent expected setup from being inherited
+      #   correctly.
+      #
+      #   Additionally, `let` and `subject` are affected by scoping rules.
+      #   When `include_examples` is used, `let` and `subject` defined within
+      #   `shared_examples` are evaluated in the caller's context, allowing
+      #   access to their values.
+      #   In contrast, `it_behaves_like` creates a new context, preventing
+      #   access to `let` or `subject` values from the caller's context.
+      #
+      #   [source,ruby]
+      #   ----
+      #   shared_examples "mock behavior" do
+      #     before do
+      #       allow(service).to receive(:call).and_return("mocked response")
+      #     end
+      #
+      #     it "returns mocked response" do
+      #       expect(service.call).to eq "mocked response"
+      #     end
+      #   end
+      #
+      #   context "working example with include_examples" do
+      #     let(:service) { double(:service) }
+      #
+      #     include_examples "mock behavior"
+      #
+      #     it "uses the mocked service" do
+      #       expect(service.call).to eq "mocked response" # Passes
+      #     end
+      #   end
+      #
+      #   context "broken example with it_behaves_like" do
+      #     let(:service) { double(:service) }
+      #
+      #     it_behaves_like "mock behavior"
+      #
+      #     it "unexpectedly does not use the mocked service" do
+      #       # Fails because `it_behaves_like` does not apply the mock setup
+      #       expect(service.call).to eq "mocked response"
+      #     end
+      #   end
+      # ----
+      #
+      # @example
+      #   # bad
+      #   include_examples 'examples'
+      #
+      #   # good
+      #   it_behaves_like 'examples'
+      #
+      class IncludeExamples < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `it_behaves_like` over `include_examples`.'
+
+        RESTRICT_ON_SEND = %i[include_examples].freeze
+
+        def on_send(node)
+          selector = node.loc.selector
+
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it_behaves_like')
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/indexed_let.rb b/lib/rubocop/cop/rspec/indexed_let.rb
new file mode 100644
index 000000000..1afc46112
--- /dev/null
+++ b/lib/rubocop/cop/rspec/indexed_let.rb
@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+      #
+      # It makes reading the test harder because it's not clear what exactly
+      # is tested by this particular example.
+      #
+      # The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+      # will also read those set in `Naming/VariableNumber`.
+      #
+      # @example `Max: 1 (default)`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      #   let(:item1) { create(:item) }
+      #   let(:item2) { create(:item) }
+      #
+      #   # good
+      #
+      #   let(:visible_item) { create(:item, visible: true) }
+      #   let(:invisible_item) { create(:item, visible: false) }
+      #
+      # @example `Max: 2`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #   let(:item_3) { create(:item) }
+      #
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedIdentifiers: ['item_1', 'item_2']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedPatterns: ['item']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      class IndexedLet < Base
+        include AllowedIdentifiers
+        include AllowedPattern
+
+        MSG = 'This `let` statement uses `%<index>s` in its name. ' \
+              'Please give it a meaningful name.'
+
+        # @!method let_name(node)
+        def_node_matcher :let_name, <<~PATTERN
+          {
+            (block (send nil? #Helpers.all ({str sym} $_) ...) ...)
+            (send nil? #Helpers.all ({str sym} $_) block_pass)
+          }
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
+
+          children = node.body&.child_nodes
+          return unless children
+
+          filter_indexed_lets(children).each do |let_node|
+            index = let_name(let_node)[INDEX_REGEX]
+            add_offense(let_node, message: format(MSG, index: index))
+          end
+        end
+
+        private
+
+        SUFFIX_INDEX_REGEX = /_?\d+$/.freeze
+        private_constant :SUFFIX_INDEX_REGEX
+        INDEX_REGEX = /\d+/.freeze
+        private_constant :INDEX_REGEX
+
+        def filter_indexed_lets(candidates)
+          candidates
+            .filter { |node| indexed_let?(node) }
+            .group_by { |node| let_name_stripped_index(node) }
+            .values
+            .filter { |lets| lets.length > cop_config['Max'] }
+            .flatten
+        end
+
+        def indexed_let?(node)
+          let?(node) &&
+            SUFFIX_INDEX_REGEX.match?(let_name(node)) &&
+            !allowed_identifier?(let_name(node).to_s) &&
+            !matches_allowed_pattern?(let_name(node).to_s)
+        end
+
+        def let_name_stripped_index(node)
+          let_name(node).to_s.gsub(INDEX_REGEX, '')
+        end
+
+        def cop_config_patterns_values
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedPatterns', [])) +
+            Array(cop_config.fetch('AllowedPatterns', []))
+        end
+
+        def allowed_identifiers
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedIdentifiers', [])) +
+            Array(cop_config.fetch('AllowedIdentifiers', []))
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/instance_spy.rb b/lib/rubocop/cop/rspec/instance_spy.rb
index 7b80c167a..cca5a1e6a 100644
--- a/lib/rubocop/cop/rspec/instance_spy.rb
+++ b/lib/rubocop/cop/rspec/instance_spy.rb
@@ -18,18 +18,22 @@ module RSpec
       #     expect(foo).to have_received(:bar)
       #   end
       #
-      class InstanceSpy < Cop
-        MSG = 'Use `instance_spy` when you check your double '\
+      class InstanceSpy < Base
+        extend AutoCorrector
+
+        MSG = 'Use `instance_spy` when you check your double ' \
               'with `have_received`.'
 
-        def_node_search :null_double, <<-PATTERN
+        # @!method null_double(node)
+        def_node_search :null_double, <<~PATTERN
           (lvasgn $_
             (send
               $(send nil? :instance_double
                 ...) :as_null_object))
         PATTERN
 
-        def_node_search :have_received_usage, <<-PATTERN
+        # @!method have_received_usage(node)
+        def_node_search :have_received_usage, <<~PATTERN
           (send
             (send nil? :expect
             (lvar $_)) :to
@@ -38,27 +42,31 @@ class InstanceSpy < Cop
           ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example?(node)
 
           null_double(node) do |var, receiver|
             have_received_usage(node) do |expected|
-              add_offense(receiver) if expected == var
+              next if expected != var
+
+              add_offense(receiver) do |corrector|
+                autocorrect(corrector, receiver)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = 'instance_spy'
-            corrector.replace(node.loc.selector, replacement)
+        private
 
-            double_source_map = node.parent.loc
-            as_null_object_range = double_source_map
-              .dot
-              .join(double_source_map.selector)
-            corrector.remove(as_null_object_range)
-          end
+        def autocorrect(corrector, node)
+          replacement = 'instance_spy'
+          corrector.replace(node.loc.selector, replacement)
+
+          double_source_map = node.parent.loc
+          as_null_object_range = double_source_map
+            .dot
+            .join(double_source_map.selector)
+          corrector.remove(as_null_object_range)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/instance_variable.rb b/lib/rubocop/cop/rspec/instance_variable.rb
index 3dfec9859..181619b83 100644
--- a/lib/rubocop/cop/rspec/instance_variable.rb
+++ b/lib/rubocop/cop/rspec/instance_variable.rb
@@ -24,10 +24,9 @@ module RSpec
       #   end
       #
       # @example with AssignmentOnly configuration
-      #
       #   # rubocop.yml
       #   # RSpec/InstanceVariable:
-      #   #   AssignmentOnly: false
+      #   #   AssignmentOnly: true
       #
       #   # bad
       #   describe MyClass do
@@ -46,32 +45,32 @@ module RSpec
       #     it { expect(foo).to be_empty }
       #   end
       #
-      class InstanceVariable < Cop
-        MSG = 'Avoid instance variables – use let, ' \
-              'a method call, or a local variable (if possible).'
-
-        EXAMPLE_GROUP_METHODS = ExampleGroups::ALL + SharedGroups::ALL
+      class InstanceVariable < Base
+        include TopLevelGroup
 
-        def_node_matcher :spec_group?, EXAMPLE_GROUP_METHODS.block_pattern
+        MSG = 'Avoid instance variables - use let, ' \
+              'a method call, or a local variable (if possible).'
 
-        def_node_matcher :dynamic_class?, <<-PATTERN
+        # @!method dynamic_class?(node)
+        def_node_matcher :dynamic_class?, <<~PATTERN
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
 
-        def_node_matcher :custom_matcher?, <<-PATTERN
+        # @!method custom_matcher?(node)
+        def_node_matcher :custom_matcher?, <<~PATTERN
           (block {
             (send nil? :matcher sym)
             (send (const (const nil? :RSpec) :Matchers) :define sym)
           } ...)
         PATTERN
 
+        # @!method ivar_usage(node)
         def_node_search :ivar_usage, '$(ivar $_)'
 
+        # @!method ivar_assigned?(node)
         def_node_search :ivar_assigned?, '(ivasgn % ...)'
 
-        def on_block(node)
-          return unless spec_group?(node)
-
+        def on_top_level_group(node)
           ivar_usage(node) do |ivar, name|
             next if valid_usage?(ivar)
             next if assignment_only? && !ivar_assigned?(node, name)
diff --git a/lib/rubocop/cop/rspec/invalid_predicate_matcher.rb b/lib/rubocop/cop/rspec/invalid_predicate_matcher.rb
deleted file mode 100644
index c0944de78..000000000
--- a/lib/rubocop/cop/rspec/invalid_predicate_matcher.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Checks invalid usage for predicate matcher.
-      #
-      # Predicate matcher does not need a question.
-      # This cop checks an unnecessary question in predicate matcher.
-      #
-      # @example
-      #
-      #   # bad
-      #   expect(foo).to be_something?
-      #
-      #   # good
-      #   expect(foo).to be_something
-      class InvalidPredicateMatcher < Cop
-        MSG = 'Omit `?` from `%<matcher>s`.'
-
-        def_node_matcher :invalid_predicate_matcher?, <<-PATTERN
-          (send (send nil? :expect ...) #{Runners::ALL.node_pattern_union} $(send nil? #predicate?))
-        PATTERN
-
-        def on_send(node)
-          invalid_predicate_matcher?(node) do |predicate|
-            add_offense(predicate)
-          end
-        end
-
-        private
-
-        def predicate?(name)
-          name = name.to_s
-          name.start_with?('be_', 'have_') && name.end_with?('?')
-        end
-
-        def message(predicate)
-          format(MSG, matcher: predicate.method_name)
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/is_expected_specify.rb b/lib/rubocop/cop/rspec/is_expected_specify.rb
new file mode 100644
index 000000000..dd03383f9
--- /dev/null
+++ b/lib/rubocop/cop/rspec/is_expected_specify.rb
@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `specify` with `is_expected` and one-liner expectations.
+      #
+      # @example
+      #   # bad
+      #   specify { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   specify do
+      #     # ...
+      #   end
+      #   specify { expect(sqrt(4)).to eq(2) }
+      #
+      class IsExpectedSpecify < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[specify].freeze
+        IS_EXPECTED_METHODS = ::Set[:is_expected, :are_expected].freeze
+        MSG = 'Use `it` instead of `specify`.'
+
+        # @!method offense?(node)
+        def_node_matcher :offense?, <<~PATTERN
+          (block (send _ :specify) _ (send (send _ IS_EXPECTED_METHODS) ...))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.single_line? && offense?(block_node)
+
+          selector = node.loc.selector
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it')
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/it_behaves_like.rb b/lib/rubocop/cop/rspec/it_behaves_like.rb
index 6da6f241d..a8f76cbac 100644
--- a/lib/rubocop/cop/rspec/it_behaves_like.rb
+++ b/lib/rubocop/cop/rspec/it_behaves_like.rb
@@ -5,37 +5,39 @@ module Cop
     module RSpec
       # Checks that only one `it_behaves_like` style is used.
       #
-      # @example when configuration is `EnforcedStyle: it_behaves_like`
+      # @example `EnforcedStyle: it_behaves_like` (default)
       #   # bad
       #   it_should_behave_like 'a foo'
       #
       #   # good
       #   it_behaves_like 'a foo'
       #
-      # @example when configuration is `EnforcedStyle: it_should_behave_like`
+      # @example `EnforcedStyle: it_should_behave_like`
       #   # bad
       #   it_behaves_like 'a foo'
       #
       #   # good
       #   it_should_behave_like 'a foo'
-      class ItBehavesLike < Cop
+      #
+      class ItBehavesLike < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including '\
+        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including ' \
               'examples in a nested context.'
+        RESTRICT_ON_SEND = %i[it_behaves_like it_should_behave_like].freeze
 
+        # @!method example_inclusion_offense(node)
         def_node_matcher :example_inclusion_offense, '(send _ % ...)'
 
         def on_send(node)
           example_inclusion_offense(node, alternative_style) do
-            add_offense(node)
+            add_offense(node) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)
diff --git a/lib/rubocop/cop/rspec/iterated_expectation.rb b/lib/rubocop/cop/rspec/iterated_expectation.rb
index 0da8ec134..2eb7ee6aa 100644
--- a/lib/rubocop/cop/rspec/iterated_expectation.rb
+++ b/lib/rubocop/cop/rspec/iterated_expectation.rb
@@ -15,11 +15,13 @@ module RSpec
       #   it 'validates users' do
       #     expect([user1, user2, user3]).to all(be_valid)
       #   end
-      class IteratedExpectation < Cop
+      #
+      class IteratedExpectation < Base
         MSG = 'Prefer using the `all` matcher instead ' \
-                  'of iterating over an array.'
+              'of iterating over an array.'
 
-        def_node_matcher :each?, <<-PATTERN
+        # @!method each?(node)
+        def_node_matcher :each?, <<~PATTERN
           (block
             (send ... :each)
             (args (arg $_))
@@ -27,7 +29,15 @@ class IteratedExpectation < Cop
           )
         PATTERN
 
-        def_node_matcher :expectation?, <<-PATTERN
+        # @!method each_numblock?(node)
+        def_node_matcher :each_numblock?, <<~PATTERN
+          (numblock
+            (send ... :each) _ $(...)
+          )
+        PATTERN
+
+        # @!method expectation?(node)
+        def_node_matcher :expectation?, <<~PATTERN
           (send (send nil? :expect (lvar %)) :to ...)
         PATTERN
 
@@ -39,6 +49,14 @@ def on_block(node)
           end
         end
 
+        def on_numblock(node)
+          each_numblock?(node) do |body|
+            if single_expectation?(body, :_1) || only_expectations?(body, :_1)
+              add_offense(node.send_node)
+            end
+          end
+        end
+
         private
 
         def single_expectation?(body, arg)
@@ -46,6 +64,8 @@ def single_expectation?(body, arg)
         end
 
         def only_expectations?(body, arg)
+          return false unless body.each_child_node.any?
+
           body.each_child_node.all? { |child| expectation?(child, arg) }
         end
       end
diff --git a/lib/rubocop/cop/rspec/leading_subject.rb b/lib/rubocop/cop/rspec/leading_subject.rb
index 513163685..a266ef49d 100644
--- a/lib/rubocop/cop/rspec/leading_subject.rb
+++ b/lib/rubocop/cop/rspec/leading_subject.rb
@@ -7,82 +7,78 @@ module RSpec
       #
       # @example
       #   # bad
-      #     let(:params) { blah }
-      #     subject { described_class.new(params) }
+      #   let(:params) { blah }
+      #   subject { described_class.new(params) }
       #
-      #     before { do_something }
-      #     subject { described_class.new(params) }
+      #   before { do_something }
+      #   subject { described_class.new(params) }
       #
-      #     it { expect_something }
-      #     subject { described_class.new(params) }
-      #     it { expect_something_else }
+      #   it { expect_something }
+      #   subject { described_class.new(params) }
+      #   it { expect_something_else }
       #
       #
       #   # good
-      #     subject { described_class.new(params) }
-      #     let(:params) { blah }
+      #   subject { described_class.new(params) }
+      #   let(:params) { blah }
       #
       #   # good
-      #     subject { described_class.new(params) }
-      #     before { do_something }
+      #   subject { described_class.new(params) }
+      #   before { do_something }
       #
       #   # good
-      #     subject { described_class.new(params) }
-      #     it { expect_something }
-      #     it { expect_something_else }
+      #   subject { described_class.new(params) }
+      #   it { expect_something }
+      #   it { expect_something_else }
       #
-      class LeadingSubject < Cop
-        include RangeHelp
+      class LeadingSubject < Base
+        extend AutoCorrector
+        include InsideExampleGroup
 
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
-        def on_block(node)
-          return unless subject?(node) && !in_spec_block?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless subject?(node)
+          return unless inside_example_group?(node)
 
           check_previous_nodes(node)
         end
 
+        private
+
         def check_previous_nodes(node)
-          node.parent.each_child_node do |sibling|
-            if offending?(sibling)
-              add_offense(
-                node,
-                message: format(MSG, offending: sibling.method_name)
-              )
+          offending_node(node) do |offender|
+            msg = format(MSG, offending: offender.method_name)
+            add_offense(node, message: msg) do |corrector|
+              autocorrect(corrector, node, offender)
             end
-
-            break if offending?(sibling) || sibling.equal?(node)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_node = find_first_offending_node(node)
-            first_node_position = first_node.loc.expression
-            indent = "\n" + ' ' * first_node.loc.column
-            corrector.insert_before(first_node_position, node.source + indent)
-            corrector.remove(node_range(node))
-          end
-        end
+        def offending_node(node)
+          parent(node).each_child_node.find do |sibling|
+            break if sibling.equal?(node)
 
-        private
-
-        def offending?(node)
-          let?(node) || hook?(node) || example?(node)
+            yield sibling if offending?(sibling)
+          end
         end
 
-        def find_first_offending_node(node)
-          node.parent.children.find { |sibling| offending?(sibling) }
+        def parent(node)
+          node.each_ancestor(:block).first.body
         end
 
-        def node_range(node)
-          range_by_whole_lines(node.source_range, include_final_newline: true)
+        def autocorrect(corrector, node, sibling)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(sibling)
         end
 
-        def in_spec_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            example?(ancestor)
-          end
+        def offending?(node)
+          let?(node) ||
+            hook?(node) ||
+            example?(node) ||
+            spec_group?(node) ||
+            include?(node)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/leaky_constant_declaration.rb b/lib/rubocop/cop/rspec/leaky_constant_declaration.rb
index 155aef735..bb651d325 100644
--- a/lib/rubocop/cop/rspec/leaky_constant_declaration.rb
+++ b/lib/rubocop/cop/rspec/leaky_constant_declaration.rb
@@ -10,14 +10,14 @@ module RSpec
       #
       # If several examples may define a `DummyClass`, instead of being a
       # blank slate class as it will be in the first example, subsequent
-      # examples will be reopening it and modifying its behaviour in
+      # examples will be reopening it and modifying its behavior in
       # unpredictable ways.
       # Even worse when a class that exists in the codebase is reopened.
       #
       # Anonymous classes are fine, since they don't result in global
       # namespace name clashes.
       #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/mutating-constants
+      # @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants
       #
       # @example Constants leak between examples
       #   # bad
@@ -93,25 +93,28 @@ module RSpec
       #       stub_const('SomeModule::SomeClass', foo_class)
       #     end
       #   end
-      class LeakyConstantDeclaration < Cop
+      class LeakyConstantDeclaration < Base
         MSG_CONST = 'Stub constant instead of declaring explicitly.'
         MSG_CLASS = 'Stub class constant instead of declaring explicitly.'
         MSG_MODULE = 'Stub module constant instead of declaring explicitly.'
 
         def on_casgn(node)
           return unless inside_describe_block?(node)
+          return if explicit_namespace?(node.namespace)
 
           add_offense(node, message: MSG_CONST)
         end
 
         def on_class(node)
           return unless inside_describe_block?(node)
+          return if explicit_namespace?(node.identifier.namespace)
 
           add_offense(node, message: MSG_CLASS)
         end
 
         def on_module(node)
           return unless inside_describe_block?(node)
+          return if explicit_namespace?(node.identifier.namespace)
 
           add_offense(node, message: MSG_MODULE)
         end
@@ -119,11 +122,12 @@ def on_module(node)
         private
 
         def inside_describe_block?(node)
-          node.each_ancestor(:block).any?(&method(:in_example_or_shared_group?))
+          node.each_ancestor(:block).any? { |ancestor| spec_group?(ancestor) }
         end
 
-        def_node_matcher :in_example_or_shared_group?,
-                         (ExampleGroups::ALL + SharedGroups::ALL).block_pattern
+        def explicit_namespace?(namespace)
+          !namespace.nil?
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/let_before_examples.rb b/lib/rubocop/cop/rspec/let_before_examples.rb
index 5efb30d32..9a220bee5 100644
--- a/lib/rubocop/cop/rspec/let_before_examples.rb
+++ b/lib/rubocop/cop/rspec/let_before_examples.rb
@@ -6,7 +6,7 @@ module RSpec
       # Checks for `let` definitions that come after an example.
       #
       # @example
-      #   # Bad
+      #   # bad
       #   let(:foo) { bar }
       #
       #   it 'checks what foo does' do
@@ -19,7 +19,7 @@ module RSpec
       #     expect(some).to be
       #   end
       #
-      #   # Good
+      #   # good
       #   let(:foo) { bar }
       #   let(:some) { other }
       #
@@ -30,38 +30,43 @@ module RSpec
       #   it 'checks what some does' do
       #     expect(some).to be
       #   end
-      class LetBeforeExamples < Cop
-        include RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
+      class LetBeforeExamples < Base
+        extend AutoCorrector
 
         MSG = 'Move `let` before the examples in the group.'
 
-        def_node_matcher :example_or_group?, <<-PATTERN
+        # @!method example_or_group?(node)
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
-            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
-            #{Includes::EXAMPLES.send_pattern}
+            (block (send nil? {#ExampleGroups.all #Examples.all} ...) ...)
+            (send nil? #Includes.examples ...)
           }
         PATTERN
 
-        def on_block(node)
-          return unless example_group_with_body?(node)
+        # @!method include_examples?(node)
+        def_node_matcher :include_examples?, <<~PATTERN
+          {
+            (block (send nil? :include_examples ...) ...)
+            (send nil? :include_examples ...)
+          }
+        PATTERN
 
-          check_let_declarations(node.body) if multiline_block?(node.body)
+        def self.autocorrect_incompatible_with
+          [RSpec::ScatteredLet]
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_example = find_first_example(node.parent)
-            first_example_pos = first_example.loc.expression
-            indent = "\n" + ' ' * first_example.loc.column
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_group_with_body?(node)
 
-            corrector.insert_before(first_example_pos, source(node) + indent)
-            corrector.remove(node_range_with_surrounding_space(node))
-          end
+          check_let_declarations(node.body) if multiline_block?(node.body)
         end
 
         private
 
+        def example_group_with_include_examples?(body)
+          body.children.any? { |sibling| include_examples?(sibling) }
+        end
+
         def multiline_block?(block)
           block.begin_type?
         end
@@ -70,10 +75,14 @@ def check_let_declarations(node)
           first_example = find_first_example(node)
           return unless first_example
 
-          node.each_child_node do |child|
-            next if child.sibling_index < first_example.sibling_index
+          correct = !example_group_with_include_examples?(node)
 
-            add_offense(child) if let?(child)
+          first_example.right_siblings.each do |sibling|
+            next unless let?(sibling)
+
+            add_offense(sibling) do |corrector|
+              autocorrect(corrector, sibling, first_example) if correct
+            end
           end
         end
 
@@ -81,17 +90,10 @@ def find_first_example(node)
           node.children.find { |sibling| example_or_group?(sibling) }
         end
 
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          node.loc.expression.with(end_pos: final_end_location(node).end_pos)
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/let_setup.rb b/lib/rubocop/cop/rspec/let_setup.rb
index b98a67551..ba3f4ee21 100644
--- a/lib/rubocop/cop/rspec/let_setup.rb
+++ b/lib/rubocop/cop/rspec/let_setup.rb
@@ -6,36 +6,49 @@ module RSpec
       # Checks unreferenced `let!` calls being used for test setup.
       #
       # @example
-      #   # Bad
+      #   # bad
       #   let!(:my_widget) { create(:widget) }
       #
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
       #
-      #   # Good
+      #   # good
       #   it 'counts widgets' do
       #     create(:widget)
       #     expect(Widget.count).to eq(1)
       #   end
       #
-      #   # Good
+      #   # good
       #   before { create(:widget) }
       #
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
-      class LetSetup < Cop
+      class LetSetup < Base
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
-        def_node_search :let_bang, <<-PATTERN
-          (block $(send nil? :let! (sym $_)) args ...)
+        # @!method example_or_shared_group_or_including?(node)
+        def_node_matcher :example_or_shared_group_or_including?, <<~PATTERN
+          (block {
+            (send #rspec? {#SharedGroups.all #ExampleGroups.all} ...)
+            (send nil? #Includes.all ...)
+          } ...)
         PATTERN
 
+        # @!method let_bang(node)
+        def_node_matcher :let_bang, <<~PATTERN
+          {
+            (block $(send nil? :let! {(sym $_) (str $_)}) ...)
+            $(send nil? :let! {(sym $_) (str $_)} block_pass)
+          }
+        PATTERN
+
+        # @!method method_called?(node)
         def_node_search :method_called?, '(send nil? %)'
 
-        def on_block(node)
-          return unless example_group?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless example_or_shared_group_or_including?(node)
 
           unused_let_bang(node) do |let|
             add_offense(let)
@@ -45,8 +58,14 @@ def on_block(node)
         private
 
         def unused_let_bang(node)
-          let_bang(node) do |method_send, method_name|
-            yield(method_send) unless method_called?(node, method_name)
+          child_let_bang(node) do |method_send, method_name|
+            yield(method_send) unless method_called?(node, method_name.to_sym)
+          end
+        end
+
+        def child_let_bang(node, &block)
+          RuboCop::RSpec::ExampleGroup.new(node).lets.each do |let|
+            let_bang(let, &block)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/match_array.rb b/lib/rubocop/cop/rspec/match_array.rb
new file mode 100644
index 000000000..17e32a907
--- /dev/null
+++ b/lib/rubocop/cop/rspec/match_array.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks where `match_array` is used.
+      #
+      # This cop checks for the following:
+      #
+      # - Prefer `contain_exactly` when matching an array with values.
+      # - Prefer `eq` when using `match_array` with an empty array literal.
+      #
+      # @example
+      #   # bad
+      #   it { is_expected.to match_array([content1, content2]) }
+      #
+      #   # good
+      #   it { is_expected.to contain_exactly(content1, content2) }
+      #
+      #   # good
+      #   it { is_expected.to match_array([content] + array) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+      #
+      class MatchArray < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `contain_exactly` when matching an array literal.'
+        RESTRICT_ON_SEND = %i[match_array].freeze
+
+        # @!method match_array_with_empty_array?(node)
+        def_node_matcher :match_array_with_empty_array?, <<~PATTERN
+          (send nil? :match_array (array))
+        PATTERN
+
+        def on_send(node)
+          return unless node.first_argument&.array_type?
+          return if match_array_with_empty_array?(node)
+
+          check_populated_array(node)
+        end
+
+        private
+
+        def check_populated_array(node)
+          return if node.first_argument.percent_literal?
+
+          add_offense(node) do |corrector|
+            array_contents = node.arguments.flat_map(&:to_a)
+            corrector.replace(
+              node,
+              "contain_exactly(#{array_contents.map(&:source).join(', ')})"
+            )
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/message_chain.rb b/lib/rubocop/cop/rspec/message_chain.rb
index 0e9c020a2..14a09bb3a 100644
--- a/lib/rubocop/cop/rspec/message_chain.rb
+++ b/lib/rubocop/cop/rspec/message_chain.rb
@@ -9,23 +9,18 @@ module RSpec
       #   # bad
       #   allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
       #
-      #   # better
+      #   # good
       #   thing = Thing.new(baz: 42)
       #   allow(foo).to receive(:bar).and_return(thing)
       #
-      class MessageChain < Cop
+      class MessageChain < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
-
-        def_node_matcher :message_chain, <<-PATTERN
-          (send _ {:receive_message_chain :stub_chain} ...)
-        PATTERN
+        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
 
         def on_send(node)
-          message_chain(node) { add_offense(node, location: :selector) }
-        end
-
-        def message(node)
-          format(MSG, method: node.method_name)
+          add_offense(
+            node.loc.selector, message: format(MSG, method: node.method_name)
+          )
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/message_expectation.rb b/lib/rubocop/cop/rspec/message_expectation.rb
index 14b80996e..d3cb45ce1 100644
--- a/lib/rubocop/cop/rspec/message_expectation.rb
+++ b/lib/rubocop/cop/rspec/message_expectation.rb
@@ -8,7 +8,7 @@ module RSpec
       # This cop can be configured in your configuration using the
       # `EnforcedStyle` option and supports `--auto-gen-config`.
       #
-      # @example `EnforcedStyle: allow`
+      # @example `EnforcedStyle: allow` (default)
       #
       #   # bad
       #   expect(foo).to receive(:bar)
@@ -24,17 +24,19 @@ module RSpec
       #   # good
       #   expect(foo).to receive(:bar)
       #
-      class MessageExpectation < Cop
+      class MessageExpectation < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'
 
-        SUPPORTED_STYLES = %w[allow expect].freeze
+        RESTRICT_ON_SEND = %i[to].freeze
 
-        def_node_matcher :message_expectation, <<-PATTERN
+        # @!method message_expectation(node)
+        def_node_matcher :message_expectation, <<~PATTERN
           (send $(send nil? {:expect :allow} ...) :to #receive_message?)
         PATTERN
 
+        # @!method receive_message?(node)
         def_node_search :receive_message?, '(send nil? :receive ...)'
 
         def on_send(node)
@@ -42,7 +44,7 @@ def on_send(node)
             return correct_style_detected if preferred_style?(match)
 
             message = format(MSG, style: style)
-            add_offense(match, location: :selector, message: message) do
+            add_offense(match.loc.selector, message: message) do
               opposite_style_detected
             end
           end
diff --git a/lib/rubocop/cop/rspec/message_spies.rb b/lib/rubocop/cop/rspec/message_spies.rb
index 3daf12c69..57cec65e0 100644
--- a/lib/rubocop/cop/rspec/message_spies.rb
+++ b/lib/rubocop/cop/rspec/message_spies.rb
@@ -8,37 +8,45 @@ module RSpec
       # This cop can be configured in your configuration using the
       # `EnforcedStyle` option and supports `--auto-gen-config`.
       #
-      # @example `EnforcedStyle: have_received`
+      # @example `EnforcedStyle: have_received` (default)
       #
       #   # bad
       #   expect(foo).to receive(:bar)
+      #   do_something
       #
       #   # good
+      #   allow(foo).to receive(:bar) # or use instance_spy
+      #   do_something
       #   expect(foo).to have_received(:bar)
       #
       # @example `EnforcedStyle: receive`
       #
       #   # bad
+      #   allow(foo).to receive(:bar)
+      #   do_something
       #   expect(foo).to have_received(:bar)
       #
       #   # good
       #   expect(foo).to receive(:bar)
+      #   do_something
       #
-      class MessageSpies < Cop
+      class MessageSpies < Base
         include ConfigurableEnforcedStyle
 
         MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
 
-        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message '\
-                            'expectations. Setup `%<source>s` as a spy using '\
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
+                            'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
-        SUPPORTED_STYLES = %w[have_received receive].freeze
+        RESTRICT_ON_SEND = Runners.all
 
+        # @!method message_expectation(node)
         def_node_matcher :message_expectation, %(
-          (send (send nil? :expect $_) #{Runners::ALL.node_pattern_union} ...)
+          (send (send nil? :expect $_) #Runners.all ...)
         )
 
+        # @!method receive_message(node)
         def_node_search :receive_message, %(
           $(send nil? {:receive :have_received} ...)
         )
@@ -48,8 +56,7 @@ def on_send(node)
             return correct_style_detected if preferred_style?(message_matcher)
 
             add_offense(
-              message_matcher,
-              location: :selector,
+              message_matcher.loc.selector,
               message: error_message(receiver)
             ) { opposite_style_detected }
           end
@@ -73,6 +80,10 @@ def error_message(receiver)
             MSG_RECEIVE
           when :have_received
             format(MSG_HAVE_RECEIVED, source: receiver.source)
+          else
+            # :nocov:
+            :noop
+            # :nocov:
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/metadata_style.rb b/lib/rubocop/cop/rspec/metadata_style.rb
new file mode 100644
index 000000000..23b2b91dd
--- /dev/null
+++ b/lib/rubocop/cop/rspec/metadata_style.rb
@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use consistent metadata style.
+      #
+      # This cop does not support autocorrection in the case of
+      # `EnforcedStyle: hash` where the trailing metadata type is ambiguous.
+      # (e.g. `describe 'Something', :a, b`)
+      #
+      # @example EnforcedStyle: symbol (default)
+      #   # bad
+      #   describe 'Something', a: true
+      #
+      #   # good
+      #   describe 'Something', :a
+      #
+      # @example EnforcedStyle: hash
+      #   # bad
+      #   describe 'Something', :a
+      #
+      #   # good
+      #   describe 'Something', a: true
+      class MetadataStyle < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+
+        include ConfigurableEnforcedStyle
+        include Metadata
+        include RangeHelp
+
+        # @!method extract_metadata_hash(node)
+        def_node_matcher :extract_metadata_hash, <<~PATTERN
+          (send _ _ _ ... $hash)
+        PATTERN
+
+        # @!method match_boolean_metadata_pair?(node)
+        def_node_matcher :match_boolean_metadata_pair?, <<~PATTERN
+          (pair sym true)
+        PATTERN
+
+        # @!method match_ambiguous_trailing_metadata?(node)
+        def_node_matcher :match_ambiguous_trailing_metadata?, <<~PATTERN
+          (send _ _ _ ... !{hash sym})
+        PATTERN
+
+        def on_metadata(symbols, hash)
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol) if symbol.sym_type?
+          end
+
+          return unless hash
+
+          hash.pairs.each do |pair|
+            on_metadata_pair(pair)
+          end
+        end
+
+        private
+
+        def autocorrect_pair(corrector, node)
+          remove_pair(corrector, node)
+          insert_symbol(corrector, node)
+        end
+
+        def autocorrect_symbol(corrector, node)
+          return if match_ambiguous_trailing_metadata?(node.parent)
+
+          remove_symbol(corrector, node)
+          insert_pair(corrector, node)
+        end
+
+        def bad_metadata_pair?(node)
+          style == :symbol && match_boolean_metadata_pair?(node)
+        end
+
+        def bad_metadata_symbol?(_node)
+          style == :hash
+        end
+
+        def format_symbol_to_pair_source(node)
+          "#{node.value}: true"
+        end
+
+        def insert_pair(corrector, node)
+          hash_node = extract_metadata_hash(node.parent)
+          if hash_node.nil?
+            insert_pair_as_last_argument(corrector, node)
+          elsif hash_node.pairs.any?
+            insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          else
+            insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          end
+        end
+
+        def insert_pair_as_last_argument(corrector, node)
+          corrector.insert_before(
+            node.parent.location.end || node.parent.source_range.with(
+              begin_pos: node.parent.source_range.end_pos
+            ),
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.location.begin,
+            " #{format_symbol_to_pair_source(node)} "
+          )
+        end
+
+        def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.children.last,
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_symbol(corrector, node)
+          corrector.insert_after(
+            node.parent.left_sibling,
+            ", #{node.key.value.inspect}"
+          )
+        end
+
+        def message_for_style
+          format(
+            'Use %<style>s style for metadata.',
+            style: style
+          )
+        end
+
+        def on_metadata_pair(node)
+          return unless bad_metadata_pair?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_pair(corrector, node)
+          end
+        end
+
+        def on_metadata_symbol(node)
+          return unless bad_metadata_symbol?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_symbol(corrector, node)
+          end
+        end
+
+        def remove_pair(corrector, node)
+          if !node.parent.braces? || node.left_siblings.any?
+            remove_pair_following(corrector, node)
+          elsif node.right_siblings.any?
+            remove_pair_preceding(corrector, node)
+          else
+            corrector.remove(node)
+          end
+        end
+
+        def remove_pair_following(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def remove_pair_preceding(corrector, node)
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+        end
+
+        def remove_symbol(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/missing_example_group_argument.rb b/lib/rubocop/cop/rspec/missing_example_group_argument.rb
index b317b65bb..4522fde21 100644
--- a/lib/rubocop/cop/rspec/missing_example_group_argument.rb
+++ b/lib/rubocop/cop/rspec/missing_example_group_argument.rb
@@ -19,10 +19,11 @@ module RSpec
       #
       #   describe "A feature example" do
       #   end
-      class MissingExampleGroupArgument < Cop
+      #
+      class MissingExampleGroupArgument < Base
         MSG = 'The first argument to `%<method>s` should not be empty.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group?(node)
           return if node.send_node.arguments?
 
diff --git a/lib/rubocop/cop/rspec/missing_expectation_target_method.rb b/lib/rubocop/cop/rspec/missing_expectation_target_method.rb
new file mode 100644
index 000000000..1246e8c16
--- /dev/null
+++ b/lib/rubocop/cop/rspec/missing_expectation_target_method.rb
@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if `.to`, `not_to` or `to_not` are used.
+      #
+      # The RSpec::Expectations::ExpectationTarget must use `to`, `not_to` or
+      # `to_not` to run. Therefore, this cop checks if other methods are used.
+      #
+      # @example
+      #   # bad
+      #   expect(something).kind_of? Foo
+      #   is_expected == 42
+      #   expect{something}.eq? BarError
+      #
+      #   # good
+      #   expect(something).to be_a Foo
+      #   is_expected.to eq 42
+      #   expect{something}.to raise_error BarError
+      #
+      class MissingExpectationTargetMethod < Base
+        MSG = 'Use `.to`, `.not_to` or `.to_not` to set an expectation.'
+        RESTRICT_ON_SEND = %i[expect is_expected].freeze
+
+        # @!method expect?(node)
+        def_node_matcher :expect?, <<~PATTERN
+          {
+            (send nil? :expect ...)
+            (send nil? :is_expected)
+          }
+        PATTERN
+
+        # @!method expect_block?(node)
+        def_node_matcher :expect_block?, <<~PATTERN
+          (block #expect? (args) _body)
+        PATTERN
+
+        # @!method expectation_without_runner?(node)
+        def_node_matcher :expectation_without_runner?, <<~PATTERN
+          (send {#expect? #expect_block?} !#Runners.all ...)
+        PATTERN
+
+        def on_send(node)
+          node = node.parent if node.parent&.block_type?
+
+          expectation_without_runner?(node.parent) do
+            add_offense(node.parent.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/comments_help.rb b/lib/rubocop/cop/rspec/mixin/comments_help.rb
new file mode 100644
index 000000000..297d0501e
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/comments_help.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for working with nodes containing comments.
+      module CommentsHelp
+        include FinalEndLocation
+
+        def source_range_with_comment(node)
+          begin_pos = begin_pos_with_comment(node).begin_pos
+          end_pos = end_line_position(node).end_pos
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def begin_pos_with_comment(node)
+          first_comment = processed_source.ast_with_comments[node].first
+
+          start_line_position(first_comment || node)
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line)
+        end
+
+        def end_line_position(node)
+          end_line = buffer.line_for_position(final_end_location(node).end_pos)
+          buffer.line_range(end_line)
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb b/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb
new file mode 100644
index 000000000..6594908b0
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps determine the offending location if there is not an empty line
+      # following the node. Allows comments to follow directly after
+      # in the following cases.
+      # - `rubocop:enable` directive
+      # - followed by empty line(s)
+      module EmptyLineSeparation
+        include FinalEndLocation
+        include RangeHelp
+
+        def missing_separating_line_offense(node)
+          return if last_child?(node)
+
+          missing_separating_line(node) do |location|
+            msg = yield(node.method_name)
+            add_offense(location, message: msg) do |corrector|
+              corrector.insert_after(location.end, "\n")
+            end
+          end
+        end
+
+        def missing_separating_line(node)
+          line = final_end_line = final_end_location(node).line
+          while processed_source.line_with_comment?(line + 1)
+            line += 1
+            comment = processed_source.comment_at_line(line)
+            if DirectiveComment.new(comment).enabled?
+              enable_directive_line = line
+            end
+          end
+
+          return if processed_source[line].blank?
+
+          yield offending_loc(enable_directive_line || final_end_line)
+        end
+
+        def offending_loc(last_line)
+          offending_line = processed_source[last_line - 1]
+
+          content_length = offending_line.lstrip.length
+          start          = offending_line.length - content_length
+
+          source_range(processed_source.buffer,
+                       last_line, start, content_length)
+        end
+
+        def last_child?(node)
+          return true unless node.parent&.begin_type?
+
+          node.equal?(node.parent.children.last)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/file_help.rb b/lib/rubocop/cop/rspec/mixin/file_help.rb
new file mode 100644
index 000000000..22bfc3f22
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/file_help.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for file.
+      module FileHelp
+        def expanded_file_path
+          File.expand_path(processed_source.file_path)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/final_end_location.rb b/lib/rubocop/cop/rspec/mixin/final_end_location.rb
new file mode 100644
index 000000000..526049f5d
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/final_end_location.rb
@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps find the true end location of nodes which might contain heredocs.
+      module FinalEndLocation
+        def final_end_location(start_node)
+          heredoc_endings =
+            start_node.each_node(:str, :dstr, :xstr)
+              .select(&:heredoc?)
+              .map { |node| node.loc.heredoc_end }
+
+          [start_node.loc.end, *heredoc_endings].max_by(&:line)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/inside_example_group.rb b/lib/rubocop/cop/rspec/mixin/inside_example_group.rb
new file mode 100644
index 000000000..ffd3958dd
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/inside_example_group.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps you identify whether a given node
+      # is within an example group or not.
+      module InsideExampleGroup
+        private
+
+        def inside_example_group?(node)
+          return spec_group?(node) if example_group_root?(node)
+
+          root = node.ancestors.find { |parent| example_group_root?(parent) }
+
+          spec_group?(root)
+        end
+
+        def example_group_root?(node)
+          node.parent.nil? || example_group_root_with_siblings?(node.parent)
+        end
+
+        def example_group_root_with_siblings?(node)
+          node.begin_type? && node.parent.nil?
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/location_help.rb b/lib/rubocop/cop/rspec/mixin/location_help.rb
new file mode 100644
index 000000000..69e1ce3aa
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/location_help.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods to location.
+      module LocationHelp
+        module_function
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Parser::Source::Range]
+        # @example
+        #   foo 1, 2
+        #      ^^^^^
+        def arguments_with_whitespace(node)
+          node.loc.selector.end.with(
+            end_pos: node.source_range.end_pos
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Parser::Source::Range]
+        # @example
+        #   foo { bar }
+        #      ^^^^^^^^
+        def block_with_whitespace(node)
+          return unless (parent = node.parent)
+          return unless parent.block_type?
+
+          node.source_range.end.with(
+            end_pos: parent.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/metadata.rb b/lib/rubocop/cop/rspec/mixin/metadata.rb
new file mode 100644
index 000000000..325747433
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/metadata.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods to find RSpec metadata.
+      module Metadata
+        extend RuboCop::NodePattern::Macros
+
+        include RuboCop::RSpec::Language
+
+        # @!method rspec_metadata(node)
+        def_node_matcher :rspec_metadata, <<~PATTERN
+          (block
+            (send
+              #rspec? {#Examples.all #ExampleGroups.all #SharedGroups.all #Hooks.all} _ $...)
+            ...)
+        PATTERN
+
+        # @!method rspec_configure(node)
+        def_node_matcher :rspec_configure, <<~PATTERN
+          (block (send #rspec? :configure) (args (arg $_)) ...)
+        PATTERN
+
+        # @!method metadata_in_block(node)
+        def_node_search :metadata_in_block, <<~PATTERN
+          (send (lvar %) #Hooks.all _ $...)
+        PATTERN
+
+        def on_block(node)
+          rspec_configure(node) do |block_var|
+            metadata_in_block(node, block_var) do |metadata_arguments|
+              on_metadata_arguments(metadata_arguments)
+            end
+          end
+
+          rspec_metadata(node) do |metadata_arguments|
+            on_metadata_arguments(metadata_arguments)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_metadata(_symbols, _hash)
+          raise ::NotImplementedError
+        end
+
+        private
+
+        def on_metadata_arguments(metadata_arguments)
+          if metadata_arguments.last&.hash_type?
+            *metadata_arguments, hash = metadata_arguments
+            on_metadata(metadata_arguments, hash)
+          else
+            on_metadata(metadata_arguments, nil)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/namespace.rb b/lib/rubocop/cop/rspec/mixin/namespace.rb
new file mode 100644
index 000000000..f39555ad5
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/namespace.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps to find namespace of the node.
+      module Namespace
+        private
+
+        # @param node [RuboCop::AST::Node]
+        # @return [Array<String>]
+        # @example
+        #   namespace(node) # => ['A', 'B', 'C']
+        def namespace(node)
+          node
+            .each_ancestor(:class, :module)
+            .reverse_each
+            .flat_map { |ancestor| ancestor.defined_module_name.split('::') }
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/skip_or_pending.rb b/lib/rubocop/cop/rspec/mixin/skip_or_pending.rb
new file mode 100644
index 000000000..1d8065b3c
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/skip_or_pending.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps check offenses with variable definitions
+      module SkipOrPending
+        extend RuboCop::NodePattern::Macros
+
+        # @!method skipped_in_metadata?(node)
+        def_node_matcher :skipped_in_metadata?, <<~PATTERN
+          {
+            (send _ _ <(sym {:skip :pending}) ...>)
+            (send _ _ ... (hash <(pair (sym {:skip :pending}) { true str dstr }) ...>))
+          }
+        PATTERN
+
+        # @!method skip_or_pending_inside_block?(node)
+        #   Match skip/pending statements inside a block (e.g. `context`)
+        #
+        #   @example source that matches
+        #     context 'when color is blue' do
+        #       skip 'not implemented yet'
+        #       pending 'not implemented yet'
+        #     end
+        #
+        #   @example source that does not match
+        #     skip 'not implemented yet'
+        #     pending 'not implemented yet'
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :skip_or_pending_inside_block?, <<~PATTERN
+          (block <(send nil? {:skip :pending} ...) ...>)
+        PATTERN
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/top_level_group.rb b/lib/rubocop/cop/rspec/mixin/top_level_group.rb
new file mode 100644
index 000000000..958af7523
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/top_level_group.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods for top level example group cops
+      module TopLevelGroup
+        extend RuboCop::NodePattern::Macros
+
+        DEPRECATED_MODULE_METHOD_WARNING =
+          'top_level_group? is deprecated and will be ' \
+          'removed in the next major version of rubocop_rspec.'
+
+        def on_new_investigation
+          super
+
+          top_level_groups.each do |node|
+            on_top_level_example_group(node) if example_group?(node)
+            on_top_level_group(node)
+          end
+        end
+
+        def top_level_groups
+          @top_level_groups ||=
+            top_level_nodes(root_node).select { |n| spec_group?(n) }
+        end
+
+        private
+
+        # Dummy methods to be overridden in the consumer
+        def on_top_level_example_group(_node); end
+
+        def on_top_level_group(_node); end
+
+        # @private
+        # @deprecated All callers of this method have been removed.
+        def top_level_group?(node)
+          warn DEPRECATED_MODULE_METHOD_WARNING, uplevel: 1
+          top_level_groups.include?(node)
+        end
+
+        def top_level_nodes(node)
+          return [] if node.nil?
+
+          case node.type
+          when :begin
+            node.children
+          when :module, :class
+            top_level_nodes(node.body)
+          else
+            [node]
+          end
+        end
+
+        def root_node
+          processed_source.ast
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/mixin/variable.rb b/lib/rubocop/cop/rspec/mixin/variable.rb
new file mode 100644
index 000000000..e469cd335
--- /dev/null
+++ b/lib/rubocop/cop/rspec/mixin/variable.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps check offenses with variable definitions
+      module Variable
+        extend RuboCop::NodePattern::Macros
+
+        Subjects = RuboCop::RSpec::Language::Subjects
+        Helpers = RuboCop::RSpec::Language::Helpers
+
+        # @!method variable_definition?(node)
+        def_node_matcher :variable_definition?, <<~PATTERN
+          (send nil? {#Subjects.all #Helpers.all}
+            $({sym str dsym dstr} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/multiple_describes.rb b/lib/rubocop/cop/rspec/multiple_describes.rb
index 79d28cd3f..69199a592 100644
--- a/lib/rubocop/cop/rspec/multiple_describes.rb
+++ b/lib/rubocop/cop/rspec/multiple_describes.rb
@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks for multiple top level describes.
+      # Checks for multiple top-level example groups.
       #
       # Multiple descriptions for the same class or module should either
       # be nested or separated into different test files.
@@ -22,17 +22,20 @@ module RSpec
       #     describe '.do_something_else' do
       #     end
       #   end
-      class MultipleDescribes < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      #
+      class MultipleDescribes < Base
+        include TopLevelGroup
+
+        MSG = 'Do not use multiple top-level example groups - try to nest them.'
 
-        MSG = 'Do not use multiple top level describes - '\
-              'try to nest them.'
+        def on_top_level_group(node)
+          top_level_example_groups =
+            top_level_groups.select { |group| example_group?(group) }
 
-        def on_top_level_describe(node, _args)
-          return if single_top_level_describe?
-          return unless top_level_nodes.first.equal?(node)
+          return if top_level_example_groups.one?
+          return unless top_level_example_groups.first.equal?(node)
 
-          add_offense(node)
+          add_offense(node.send_node)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/multiple_expectations.rb b/lib/rubocop/cop/rspec/multiple_expectations.rb
index 2910d5213..bb1a32297 100644
--- a/lib/rubocop/cop/rspec/multiple_expectations.rb
+++ b/lib/rubocop/cop/rspec/multiple_expectations.rb
@@ -11,7 +11,6 @@ module RSpec
       # and works with `--auto-gen-config`.
       #
       # @example
-      #
       #   # bad
       #   describe UserCreator do
       #     it 'builds a user' do
@@ -31,13 +30,26 @@ module RSpec
       #     end
       #   end
       #
-      # @example configuration
+      # @example `aggregate_failures: true` (default)
+      #   # good - the cop ignores when RSpec aggregates failures
+      #   describe UserCreator do
+      #     it 'builds a user', :aggregate_failures do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # .rubocop.yml
-      #   # RSpec/MultipleExpectations:
-      #   #   Max: 2
+      # @example `aggregate_failures: false`
+      #   # Detected as an offense
+      #   describe UserCreator do
+      #     it 'builds a user', aggregate_failures: false do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # not flagged by rubocop
+      # @example `Max: 1` (default)
+      #   # bad
       #   describe UserCreator do
       #     it 'builds a user' do
       #       expect(user.name).to eq("John")
@@ -45,31 +57,40 @@ module RSpec
       #     end
       #   end
       #
-      class MultipleExpectations < Cop
-        include ConfigurableMax
-
+      # @example `Max: 2`
+      #   # good
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
+      #
+      class MultipleExpectations < Base
         MSG = 'Example has too many expectations [%<total>d/%<max>d].'
 
-        def_node_matcher :aggregate_failures?, <<-PATTERN
-          (block {
-              (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) true) ...>))
-            } ...)
-        PATTERN
+        ANYTHING = ->(_node) { true }
+        TRUE_NODE = lambda(&:true_type?)
+
+        exclude_limit 'Max'
 
-        def_node_matcher :aggregate_failures_present?, <<-PATTERN
+        # @!method aggregate_failures?(node)
+        def_node_matcher :aggregate_failures?, <<~PATTERN
           (block {
               (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) _) ...>))
+              (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
             } ...)
         PATTERN
 
-        def_node_matcher :expect?, Expectations::ALL.send_pattern
-        def_node_matcher :aggregate_failures_block?, <<-PATTERN
+        # @!method expect?(node)
+        def_node_matcher :expect?, '(send nil? #Expectations.all ...)'
+
+        # @!method aggregate_failures_block?(node)
+        def_node_matcher :aggregate_failures_block?, <<~PATTERN
           (block (send nil? :aggregate_failures ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example?(node)
 
           return if example_with_aggregate_failures?(node)
@@ -89,12 +110,12 @@ def example_with_aggregate_failures?(example_node)
           node_with_aggregate_failures = find_aggregate_failures(example_node)
           return false unless node_with_aggregate_failures
 
-          aggregate_failures?(node_with_aggregate_failures)
+          aggregate_failures?(node_with_aggregate_failures, TRUE_NODE)
         end
 
         def find_aggregate_failures(example_node)
           example_node.send_node.each_ancestor(:block)
-            .find { |block_node| aggregate_failures_present?(block_node) }
+            .find { |block_node| aggregate_failures?(block_node, ANYTHING) }
         end
 
         def find_expectation(node, &block)
diff --git a/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb b/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb
new file mode 100644
index 000000000..b15dba208
--- /dev/null
+++ b/lib/rubocop/cop/rspec/multiple_memoized_helpers.rb
@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if example groups contain too many `let` and `subject` calls.
+      #
+      # This cop is configurable using the `Max` option and the `AllowSubject`
+      # which will configure the cop to only register offenses on calls to
+      # `let` and not calls to `subject`.
+      #
+      # @example
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #
+      #     context 'when stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     context 'when stuff' do
+      #       let(:foo) { [] }
+      #       let(:bar) { [] }
+      #       let!(:booger) { [] }
+      #     end
+      #
+      #     context 'when other stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      # @example when disabling AllowSubject configuration
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   AllowSubject: false
+      #
+      #   # bad - `subject` counts towards memoized helpers
+      #   describe MyClass do
+      #     subject { {} }
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #   end
+      #
+      # @example with Max configuration
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   Max: 1
+      #
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #   end
+      #
+      class MultipleMemoizedHelpers < Base
+        include Variable
+
+        MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
+
+        exclude_limit 'Max'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
+
+          count = all_helpers(node).uniq.count
+
+          return if count <= max
+
+          self.max = count
+          add_offense(node, message: format(MSG, count: count, max: max))
+        end
+
+        def on_new_investigation
+          super
+          @example_group_memoized_helpers = {}
+        end
+
+        private
+
+        attr_reader :example_group_memoized_helpers
+
+        def all_helpers(node)
+          helpers(node) +
+            node.each_ancestor(:block).flat_map { |ancestor| helpers(ancestor) }
+        end
+
+        def helpers(node)
+          @example_group_memoized_helpers[node] ||=
+            variable_nodes(node).map do |variable_node|
+              if variable_node.block_type?
+                variable_definition?(variable_node.send_node)
+              else # block-pass (`let(:foo, &bar)`)
+                variable_definition?(variable_node)
+              end
+            end
+        end
+
+        def variable_nodes(node)
+          example_group = RuboCop::RSpec::ExampleGroup.new(node)
+
+          if allow_subject?
+            example_group.lets
+          else
+            example_group.lets + example_group.subjects
+          end
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_subject?
+          cop_config['AllowSubject']
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/multiple_subjects.rb b/lib/rubocop/cop/rspec/multiple_subjects.rb
index f6d7d1c25..43017ee07 100644
--- a/lib/rubocop/cop/rspec/multiple_subjects.rb
+++ b/lib/rubocop/cop/rspec/multiple_subjects.rb
@@ -6,7 +6,6 @@ module RSpec
       # Checks if an example group defines `subject` multiple times.
       #
       # @example
-      #
       #   # bad
       #   describe Foo do
       #     subject(:user) { User.new }
@@ -19,6 +18,21 @@ module RSpec
       #     subject(:post) { Post.new }
       #   end
       #
+      #   # bad (does not support autocorrection)
+      #   describe Foo do
+      #     subject!(:user) { User.new }
+      #     subject!(:post) { Post.new }
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     before do
+      #       User.new
+      #       Post.new
+      #     end
+      #   end
+      #
+      # This cop does not support autocorrection in some cases.
       # The autocorrect behavior for this cop depends on the type of
       # duplication:
       #
@@ -33,49 +47,49 @@ module RSpec
       #   - If subjects are defined with `subject!` then we don't autocorrect.
       #     This is enough of an edge case that people can just move this to
       #     a `before` hook on their own
-      class MultipleSubjects < Cop
+      #
+      class MultipleSubjects < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Do not set more than one subject per example group'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group?(node)
 
           subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
 
           subjects[0...-1].each do |subject|
-            add_offense(subject)
+            add_offense(subject) do |corrector|
+              autocorrect(corrector, subject)
+            end
           end
         end
 
-        def autocorrect(node)
-          return unless node.method_name.equal?(:subject) # Ignore `subject!`
+        private
+
+        def autocorrect(corrector, subject)
+          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
 
-          if named_subject?(node)
-            rename_autocorrect(node)
+          if named_subject?(subject)
+            rename_autocorrect(corrector, subject)
           else
-            remove_autocorrect(node)
+            remove_autocorrect(corrector, subject)
           end
         end
 
-        private
-
         def named_subject?(node)
           node.send_node.arguments?
         end
 
-        def rename_autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'let')
-          end
+        def rename_autocorrect(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'let')
         end
 
-        def remove_autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(node.source_range,
-                                         include_final_newline: true)
-            corrector.remove(range)
-          end
+        def remove_autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range,
+                                       include_final_newline: true)
+          corrector.remove(range)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/named_subject.rb b/lib/rubocop/cop/rspec/named_subject.rb
index ed12f133a..f69480051 100644
--- a/lib/rubocop/cop/rspec/named_subject.rb
+++ b/lib/rubocop/cop/rspec/named_subject.rb
@@ -6,17 +6,17 @@ module RSpec
       # Checks for explicitly referenced test subjects.
       #
       # RSpec lets you declare an "implicit subject" using `subject { ... }`
-      # which allows for tests like `it { should be_valid }`. If you need to
-      # reference your test subject you should explicitly name it using
-      # `subject(:your_subject_name) { ... }`. Your test subjects should be
-      # the most important object in your tests so they deserve a descriptive
-      # name.
-      #
-      # This cop can be configured in your configuration using the
-      # `IgnoreSharedExamples` which will not report offenses for implicit
+      # which allows for tests like `it { is_expected.to be_valid }`.
+      # If you need to reference your test subject you should explicitly
+      # name it using `subject(:your_subject_name) { ... }`. Your test subjects
+      # should be the most important object in your tests so they deserve
+      # a descriptive name.
+      #
+      # This cop can be configured in your configuration using `EnforcedStyle`,
+      # and `IgnoreSharedExamples` which will not report offenses for implicit
       # subjects in shared example groups.
       #
-      # @example
+      # @example `EnforcedStyle: always` (default)
       #   # bad
       #   RSpec.describe User do
       #     subject { described_class.new }
@@ -27,7 +27,7 @@ module RSpec
       #   end
       #
       #   # good
-      #   RSpec.describe Foo do
+      #   RSpec.describe User do
       #     subject(:user) { described_class.new }
       #
       #     it 'is valid' do
@@ -36,39 +36,119 @@ module RSpec
       #   end
       #
       #   # also good
-      #   RSpec.describe Foo do
+      #   RSpec.describe User do
       #     subject(:user) { described_class.new }
       #
-      #     it { should be_valid }
+      #     it { is_expected.to be_valid }
       #   end
-      class NamedSubject < Cop
-        MSG = 'Name your test subject if you need '\
-              'to reference it explicitly.'
-
-        def_node_matcher :rspec_block?, <<-PATTERN
-          {
-            #{Examples::ALL.block_pattern}
-            #{Hooks::ALL.block_pattern}
-          }
+      #
+      # @example `EnforcedStyle: named_only`
+      #   # bad
+      #   RSpec.describe User do
+      #     subject(:user) { described_class.new }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      #
+      #   # good
+      #   RSpec.describe User do
+      #     subject(:user) { described_class.new }
+      #
+      #     it 'is valid' do
+      #       expect(user.valid?).to be(true)
+      #     end
+      #   end
+      #
+      #   # also good
+      #   RSpec.describe User do
+      #     subject { described_class.new }
+      #
+      #     it { is_expected.to be_valid }
+      #   end
+      #
+      #   # acceptable
+      #   RSpec.describe User do
+      #     subject { described_class.new }
+      #
+      #     it 'is valid' do
+      #       expect(subject.valid?).to be(true)
+      #     end
+      #   end
+      class NamedSubject < Base
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Name your test subject if you need to reference it explicitly.'
+
+        # @!method example_or_hook_block?(node)
+        def_node_matcher :example_or_hook_block?, <<~PATTERN
+          (block (send nil? {#Examples.all #Hooks.all} ...) ...)
         PATTERN
 
-        def_node_matcher :shared_example?, <<-PATTERN
-          #{SharedGroups::EXAMPLES.block_pattern}
+        # @!method shared_example?(node)
+        def_node_matcher :shared_example?, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
         PATTERN
 
+        # @!method subject_usage(node)
         def_node_search :subject_usage, '$(send nil? :subject)'
 
-        def on_block(node)
-          return if !rspec_block?(node) || ignored_shared_example?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          if !example_or_hook_block?(node) || ignored_shared_example?(node)
+            return
+          end
 
           subject_usage(node) do |subject_node|
-            add_offense(subject_node, location: :selector)
+            check_explicit_subject(subject_node)
           end
         end
 
+        private
+
         def ignored_shared_example?(node)
-          cop_config['IgnoreSharedExamples'] &&
-            node.each_ancestor(:block).any?(&method(:shared_example?))
+          return false unless cop_config['IgnoreSharedExamples']
+
+          node.each_ancestor(:block).any? do |ancestor|
+            shared_example?(ancestor)
+          end
+        end
+
+        def check_explicit_subject(node)
+          return if allow_explicit_subject?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        def allow_explicit_subject?(node)
+          !always? && !named_only?(node)
+        end
+
+        def always?
+          style == :always
+        end
+
+        def named_only?(node)
+          style == :named_only &&
+            subject_definition_is_named?(node)
+        end
+
+        def subject_definition_is_named?(node)
+          subject = nearest_subject(node)
+
+          subject&.send_node&.arguments?
+        end
+
+        def nearest_subject(node)
+          node
+            .each_ancestor(:block)
+            .lazy
+            .map { |block_node| find_subject(block_node) }
+            .find(&:itself)
+        end
+
+        def find_subject(block_node)
+          block_node.body&.child_nodes&.find { |send_node| subject?(send_node) }
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/nested_groups.rb b/lib/rubocop/cop/rspec/nested_groups.rb
index 87da08764..f19412d0b 100644
--- a/lib/rubocop/cop/rspec/nested_groups.rb
+++ b/lib/rubocop/cop/rspec/nested_groups.rb
@@ -6,7 +6,7 @@ module RSpec
       # Checks for nested example groups.
       #
       # This cop is configurable using the `Max` option
-      # and supports `--auto-gen-config
+      # and supports `--auto-gen-config`.
       #
       # @example
       #   # bad
@@ -36,7 +36,7 @@ module RSpec
       #     end
       #   end
       #
-      #   # better
+      #   # good
       #   context 'using some feature as an admin' do
       #     let(:some)    { :various }
       #     let(:feature) { :setup   }
@@ -53,41 +53,46 @@ module RSpec
       #     it 'yada yada'
       #   end
       #
-      # @example configuration
-      #
-      #   # .rubocop.yml
-      #   # RSpec/NestedGroups:
-      #   #   Max: 2
-      #
-      #   context 'when using some feature' do
-      #     let(:some)    { :various }
-      #     let(:feature) { :setup   }
-      #
-      #     context 'when user is signed in' do
-      #       let(:user) do
-      #         UserCreate.call(user_attributes)
+      # @example `Max: 3` (default)
+      #   # bad
+      #   describe Foo do
+      #     context 'foo' do
+      #       context 'bar' do
+      #         context 'baz' do # flagged by rubocop
+      #         end
       #       end
+      #     end
+      #   end
       #
-      #       let(:user_attributes) do
-      #         {
-      #           name: 'John',
-      #           age:  22,
-      #           role: role
-      #         }
+      # @example `Max: 2`
+      #   # bad
+      #   describe Foo do
+      #     context 'foo' do
+      #       context 'bar' do # flagged by rubocop
+      #         context 'baz' do # flagged by rubocop
+      #         end
       #       end
+      #     end
+      #   end
       #
-      #       context 'when user is an admin' do # flagged by rubocop
-      #         let(:role) { 'admin' }
+      # @example `AllowedGroups: [] (default)`
+      #   describe Foo do # <-- nested groups 1
+      #     context 'foo' do # <-- nested groups 2
+      #       context 'bar' do # <-- nested groups 3
+      #       end
+      #     end
+      #   end
       #
-      #         it 'blah blah'
-      #         it 'yada yada'
+      # @example `AllowedGroups: [path]`
+      #   describe Foo do # <-- nested groups 1
+      #     path '/foo' do # <-- nested groups 1 (not counted)
+      #       context 'bar' do # <-- nested groups 2
       #       end
       #     end
       #   end
       #
-      class NestedGroups < Cop
-        include ConfigurableMax
-        include RuboCop::RSpec::TopLevelDescribe
+      class NestedGroups < Base
+        include TopLevelGroup
 
         MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
 
@@ -97,13 +102,13 @@ class NestedGroups < Cop
           "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
           'deprecated in favor of `Max`. Please use that instead.'
 
-        def_node_search :find_contexts, ExampleGroups::ALL.block_pattern
+        exclude_limit 'Max'
 
-        def on_top_level_describe(node, _args)
-          find_nested_contexts(node.parent) do |context, nesting|
+        def on_top_level_group(node)
+          find_nested_example_groups(node) do |example_group, nesting|
             self.max = nesting
             add_offense(
-              context.send_node,
+              example_group.send_node,
               message: message(nesting)
             )
           end
@@ -111,16 +116,27 @@ def on_top_level_describe(node, _args)
 
         private
 
-        def find_nested_contexts(node, nesting: 1, &block)
-          find_contexts(node) do |nested_context|
-            yield(nested_context, nesting) if nesting > max_nesting
+        def find_nested_example_groups(node, nesting: 1, &block)
+          example_group = example_group?(node)
+          yield node, nesting if example_group && nesting > max_nesting
+
+          next_nesting = if count_up_nesting?(node, example_group)
+                           nesting + 1
+                         else
+                           nesting
+                         end
 
-            nested_context.each_child_node do |child|
-              find_nested_contexts(child, nesting: nesting + 1, &block)
-            end
+          node.each_child_node(:block, :begin) do |child|
+            find_nested_example_groups(child, nesting: next_nesting, &block)
           end
         end
 
+        def count_up_nesting?(node, example_group)
+          example_group &&
+            node.block_type? &&
+            !allowed_groups.include?(node.method_name.to_s)
+        end
+
         def message(nesting)
           format(MSG, total: nesting, max: max_nesting)
         end
@@ -137,6 +153,10 @@ def max_nesting_config
             cop_config.fetch('Max', 3)
           end
         end
+
+        def allowed_groups
+          @allowed_groups ||= cop_config.fetch('AllowedGroups', [])
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/no_expectation_example.rb b/lib/rubocop/cop/rspec/no_expectation_example.rb
new file mode 100644
index 000000000..a800636df
--- /dev/null
+++ b/lib/rubocop/cop/rspec/no_expectation_example.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if an example contains any expectation.
+      #
+      # All RSpec's example and expectation methods are covered by default.
+      # If you are using your own custom methods,
+      # add the following configuration:
+      #
+      #   RSpec:
+      #     Language:
+      #       Examples:
+      #         Regular:
+      #           - custom_it
+      #       Expectations:
+      #         - custom_expect
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     a?
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect(a?).to be(true)
+      #   end
+      #
+      # This cop can be customized with an allowed expectation methods pattern
+      # with an `AllowedPatterns` option. ^expect_ and ^assert_ are allowed
+      # by default.
+      #
+      # @example `AllowedPatterns` configuration
+      #
+      #   # .rubocop.yml
+      #   # RSpec/NoExpectationExample:
+      #   #   AllowedPatterns:
+      #   #     - ^expect_
+      #   #     - ^assert_
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     not_expect_something
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect_something
+      #   end
+      #
+      #   it do
+      #     assert_something
+      #   end
+      #
+      class NoExpectationExample < Base
+        include AllowedPattern
+        include SkipOrPending
+
+        MSG = 'No expectation found in this example.'
+
+        # @!method regular_or_focused_example?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_matcher :regular_or_focused_example?, <<~PATTERN
+          (any_block (send nil? {#Examples.regular #Examples.focused} ...) ...)
+        PATTERN
+
+        # @!method includes_expectation?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_search :includes_expectation?, <<~PATTERN
+          {
+            (send nil? #Expectations.all ...)
+            (send nil? `#matches_allowed_pattern? ...)
+          }
+        PATTERN
+
+        # @!method includes_skip_example?(node)
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def_node_search :includes_skip_example?, <<~PATTERN
+          (send nil? {:pending :skip} ...)
+        PATTERN
+
+        # @param [RuboCop::AST::BlockNode] node
+        def on_block(node)
+          return unless regular_or_focused_example?(node)
+          return if includes_expectation?(node)
+          return if includes_skip_example?(node)
+          return if skipped_in_metadata?(node.send_node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/not_to_not.rb b/lib/rubocop/cop/rspec/not_to_not.rb
index 9d7959df1..8f0968484 100644
--- a/lib/rubocop/cop/rspec/not_to_not.rb
+++ b/lib/rubocop/cop/rspec/not_to_not.rb
@@ -5,7 +5,7 @@ module Cop
     module RSpec
       # Checks for consistent method usage for negating expectations.
       #
-      # @example
+      # @example `EnforcedStyle: not_to` (default)
       #   # bad
       #   it '...' do
       #     expect(false).to_not be_true
@@ -15,23 +15,36 @@ module RSpec
       #   it '...' do
       #     expect(false).not_to be_true
       #   end
-      class NotToNot < Cop
+      #
+      # @example `EnforcedStyle: to_not`
+      #   # bad
+      #   it '...' do
+      #     expect(false).not_to be_true
+      #   end
+      #
+      #   # good
+      #   it '...' do
+      #     expect(false).to_not be_true
+      #   end
+      #
+      class NotToNot < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
+        RESTRICT_ON_SEND = %i[not_to to_not].freeze
 
+        # @!method not_to_not_offense(node)
         def_node_matcher :not_to_not_offense, '(send _ % ...)'
 
         def on_send(node)
           not_to_not_offense(node, alternative_style) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)
diff --git a/lib/rubocop/cop/rspec/overwriting_setup.rb b/lib/rubocop/cop/rspec/overwriting_setup.rb
index b43c72e68..8ca311d59 100644
--- a/lib/rubocop/cop/rspec/overwriting_setup.rb
+++ b/lib/rubocop/cop/rspec/overwriting_setup.rb
@@ -21,13 +21,19 @@ module RSpec
       #   let(:foo) { bar }
       #   let(:baz) { baz }
       #   let!(:other) { other }
-      class OverwritingSetup < Cop
+      #
+      class OverwritingSetup < Base
         MSG = '`%<name>s` is already defined.'
 
-        def_node_matcher :setup?, (Helpers::ALL + Subject::ALL).block_pattern
+        # @!method setup?(node)
+        def_node_matcher :setup?, <<~PATTERN
+          (block (send nil? {#Helpers.all #Subjects.all} ...) ...)
+        PATTERN
+
+        # @!method first_argument_name(node)
         def_node_matcher :first_argument_name, '(send _ _ ({str sym} $_))'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 
           find_duplicates(node.body) do |duplicate, name|
diff --git a/lib/rubocop/cop/rspec/pending.rb b/lib/rubocop/cop/rspec/pending.rb
index d48b41bd6..13f71a76b 100644
--- a/lib/rubocop/cop/rspec/pending.rb
+++ b/lib/rubocop/cop/rspec/pending.rb
@@ -31,24 +31,33 @@ module RSpec
       #   # good
       #   describe MyClass do
       #   end
-      class Pending < Cop
+      #
+      class Pending < Base
+        include SkipOrPending
+
         MSG = 'Pending spec found.'
 
-        PENDING = Examples::PENDING + Examples::SKIPPED + ExampleGroups::SKIPPED
-        SKIPPABLE = ExampleGroups::GROUPS + Examples::EXAMPLES
+        # @!method skippable?(node)
+        def_node_matcher :skippable?, <<~PATTERN
+          {
+            (send #rspec? #ExampleGroups.regular ...)
+            #skippable_example?
+          }
+        PATTERN
 
-        def_node_matcher :skippable?, SKIPPABLE.send_pattern
+        # @!method skippable_example?(node)
+        def_node_matcher :skippable_example?, <<~PATTERN
+          (send nil? #Examples.regular _ ...)
+        PATTERN
 
-        def_node_matcher :skipped_in_metadata?, <<-PATTERN
+        # @!method pending_block?(node)
+        def_node_matcher :pending_block?, <<~PATTERN
           {
-            (send _ _ <#skip_or_pending? ...>)
-            (send _ _ ... (hash <(pair #skip_or_pending? { true str }) ...>))
+            (send #rspec? #ExampleGroups.skipped ...)
+            (send nil? {#Examples.skipped #Examples.pending} ...)
           }
         PATTERN
 
-        def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
-        def_node_matcher :pending_block?, PENDING.send_pattern
-
         def on_send(node)
           return unless pending_block?(node) || skipped?(node)
 
@@ -58,7 +67,12 @@ def on_send(node)
         private
 
         def skipped?(node)
-          skippable?(node) && skipped_in_metadata?(node)
+          (skippable?(node) && skipped_in_metadata?(node)) ||
+            skipped_regular_example_without_body?(node)
+        end
+
+        def skipped_regular_example_without_body?(node)
+          skippable_example?(node) && !node.block_node
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/pending_without_reason.rb b/lib/rubocop/cop/rspec/pending_without_reason.rb
new file mode 100644
index 000000000..eea8edaaa
--- /dev/null
+++ b/lib/rubocop/cop/rspec/pending_without_reason.rb
@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for pending or skipped examples without reason.
+      #
+      # @example
+      #   # bad
+      #   pending 'does something' do
+      #   end
+      #
+      #   # bad
+      #   it 'does something', :pending do
+      #   end
+      #
+      #   # bad
+      #   it 'does something' do
+      #     pending
+      #   end
+      #
+      #   # bad
+      #   xdescribe 'something' do
+      #   end
+      #
+      #   # bad
+      #   skip 'does something' do
+      #   end
+      #
+      #   # bad
+      #   it 'does something', :skip do
+      #   end
+      #
+      #   # bad
+      #   it 'does something' do
+      #     skip
+      #   end
+      #
+      #   # bad
+      #   it 'does something'
+      #
+      #   # good
+      #   it 'does something' do
+      #     pending 'reason'
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     skip 'reason'
+      #   end
+      #
+      #   # good
+      #   it 'does something', pending: 'reason' do
+      #   end
+      #
+      #   # good
+      #   it 'does something', skip: 'reason' do
+      #   end
+      class PendingWithoutReason < Base
+        MSG = 'Give the reason for pending or skip.'
+
+        # @!method skipped_in_example?(node)
+        def_node_matcher :skipped_in_example?, <<~PATTERN
+          {
+            (send nil? ${#Examples.skipped #Examples.pending})
+            (any_block (send nil? ${#Examples.skipped}) ...)
+          }
+        PATTERN
+
+        # @!method skipped_by_example_method?(node)
+        def_node_matcher :skipped_by_example_method?, <<~PATTERN
+          (send nil? ${#Examples.skipped #Examples.pending})
+        PATTERN
+
+        # @!method skipped_by_example_method_with_block?(node)
+        def_node_matcher :skipped_by_example_method_with_block?, <<~PATTERN
+          (any_block (send nil? ${#Examples.skipped #Examples.pending} ...) ...)
+        PATTERN
+
+        # @!method metadata_without_reason?(node)
+        def_node_matcher :metadata_without_reason?, <<~PATTERN
+          (send #rspec?
+            {#ExampleGroups.all #Examples.all} ...
+            {
+              <(sym ${:pending :skip}) ...>
+              (hash <(pair (sym ${:pending :skip}) true) ...>)
+            }
+          )
+        PATTERN
+
+        # @!method skipped_by_example_group_method?(node)
+        def_node_matcher :skipped_by_example_group_method?, <<~PATTERN
+          (send #rspec? ${#ExampleGroups.skipped} ...)
+        PATTERN
+
+        def on_send(node)
+          on_pending_by_metadata(node)
+          return unless (parent = parent_node(node))
+
+          if spec_group?(parent) || block_node_example_group?(node)
+            on_skipped_by_example_method(node)
+            on_skipped_by_example_group_method(node)
+          elsif example?(parent)
+            on_skipped_by_in_example_method(node)
+          end
+        end
+
+        private
+
+        def parent_node(node)
+          node_or_block = node.block_node || node
+          return unless (parent = node_or_block.parent)
+
+          parent.begin_type? && parent.parent ? parent.parent : parent
+        end
+
+        def block_node_example_group?(node)
+          node.block_node &&
+            example_group?(node.block_node) &&
+            explicit_rspec?(node.receiver)
+        end
+
+        def on_skipped_by_in_example_method(node)
+          skipped_in_example?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_pending_by_metadata(node)
+          metadata_without_reason?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_method(node)
+          skipped_by_example_method?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+
+          skipped_by_example_method_with_block?(node.parent) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_group_method(node)
+          skipped_by_example_group_method?(node) do
+            add_offense(node, message: 'Give the reason for skip.')
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/predicate_matcher.rb b/lib/rubocop/cop/rspec/predicate_matcher.rb
index 65f1d7c15..fd7830ec4 100644
--- a/lib/rubocop/cop/rspec/predicate_matcher.rb
+++ b/lib/rubocop/cop/rspec/predicate_matcher.rb
@@ -14,28 +14,40 @@ module InflectedHelper
         private
 
         def check_inflected(node)
-          predicate_in_actual?(node) do |predicate|
-            add_offense(
-              node,
-              message: message_inflected(predicate)
-            )
+          predicate_in_actual?(node) do |predicate, to, matcher|
+            next if cannot_replace_predicate?(predicate)
+
+            msg = message_inflected(predicate)
+            add_offense(node, message: msg) do |corrector|
+              remove_predicate(corrector, predicate)
+              corrector.replace(node.loc.selector,
+                                true?(to, matcher) ? 'to' : 'not_to')
+              rewrite_matcher(corrector, predicate, matcher)
+            end
           end
         end
 
-        def_node_matcher :predicate_in_actual?, <<-PATTERN
+        # @!method predicate_in_actual?(node)
+        def_node_matcher :predicate_in_actual?, <<~PATTERN
           (send
             (send nil? :expect {
               (block $(send !nil? #predicate? ...) ...)
               $(send !nil? #predicate? ...)})
-            $#{Runners::ALL.node_pattern_union}
-            $#boolean_matcher?)
+            $#Runners.all
+            $#boolean_matcher? ...)
         PATTERN
 
-        def_node_matcher :be_bool?, <<-PATTERN
-          (send nil? {:be :eq :eql :equal} {true false})
+        def cannot_replace_predicate?(send_node)
+          send_node.method?(:respond_to?) && send_node.arguments.length > 1
+        end
+
+        # @!method be_bool?(node)
+        def_node_matcher :be_bool?, <<~PATTERN
+          (send nil? {:be :eq :eql :equal} boolean)
         PATTERN
 
-        def_node_matcher :be_boolthy?, <<-PATTERN
+        # @!method be_boolthy?(node)
+        def_node_matcher :be_boolthy?, <<~PATTERN
           (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
         PATTERN
 
@@ -57,7 +69,6 @@ def message_inflected(predicate)
                  matcher_name: to_predicate_matcher(predicate.method_name))
         end
 
-        # rubocop:disable Metrics/MethodLength
         def to_predicate_matcher(name)
           case name = name.to_s
           when 'is_a?'
@@ -68,63 +79,54 @@ def to_predicate_matcher(name)
             name[0..-2]
           when 'exist?', 'exists?'
             'exist'
-          when /^has_/
+          when /\Ahas_/
             name.sub('has_', 'have_')[0..-2]
           else
             "be_#{name[0..-2]}"
           end
         end
-        # rubocop:enable Metrics/MethodLength
-
-        def autocorrect_inflected(node)
-          predicate_in_actual?(node) do |predicate, to, matcher|
-            lambda do |corrector|
-              remove_predicate(corrector, predicate)
-              corrector.replace(node.loc.selector,
-                                true?(to, matcher) ? 'to' : 'not_to')
-              rewrite_matcher(corrector, predicate, matcher)
-            end
-          end
-        end
 
         def remove_predicate(corrector, predicate)
           range = predicate.loc.dot.with(
-            end_pos: predicate.loc.expression.end_pos
+            end_pos: predicate.source_range.end_pos
           )
 
           corrector.remove(range)
 
-          block_range = block_loc(predicate)
+          block_range = LocationHelp.block_with_whitespace(predicate)
           corrector.remove(block_range) if block_range
         end
 
         def rewrite_matcher(corrector, predicate, matcher)
-          args = args_loc(predicate).source
-          block_loc = block_loc(predicate)
+          args = LocationHelp.arguments_with_whitespace(predicate).source
+          block_loc = LocationHelp.block_with_whitespace(predicate)
           block = block_loc ? block_loc.source : ''
 
           corrector.replace(
-            matcher.loc.expression,
+            matcher,
             to_predicate_matcher(predicate.method_name) + args + block
           )
         end
 
         def true?(to_symbol, matcher)
           result = case matcher.method_name
-                   when :be, :eq
+                   when :be, :eq, :eql, :equal
                      matcher.first_argument.true_type?
                    when :be_truthy, :a_truthy_value
                      true
                    when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
                      false
+                   else
+                     # :nocov:
+                     :noop
+                     # :nocov:
                    end
           to_symbol == :to ? result : !result
         end
       end
 
       # A helper for `explicit` style
-      # rubocop:disable Metrics/ModuleLength
-      module ExplicitHelper
+      module ExplicitHelper # rubocop:disable Metrics/ModuleLength
         include RuboCop::RSpec::Language
         extend NodePattern::Macros
 
@@ -143,38 +145,66 @@ def allowed_explicit_matchers
         end
 
         def check_explicit(node) # rubocop:disable Metrics/MethodLength
-          predicate_matcher_block?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher_block?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              to_node = node.send_node
+              corrector_explicit(corrector, to_node, actual, matcher, to_node)
+            end
             ignore_node(node.children.first)
             return
           end
 
           return if part_of_ignored_node?(node)
 
-          predicate_matcher?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher?(node) do |actual, matcher|
+            next unless replaceable_matcher?(matcher)
+
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              next if uncorrectable_matcher?(node, matcher)
+
+              corrector_explicit(corrector, node, actual, matcher, matcher)
+            end
           end
         end
 
-        def_node_matcher :predicate_matcher?, <<-PATTERN
+        def replaceable_matcher?(matcher)
+          case matcher.method_name.to_s
+          when 'include'
+            matcher.arguments.one?
+          else
+            true
+          end
+        end
+
+        def uncorrectable_matcher?(node, matcher)
+          heredoc_argument?(matcher) && !same_line?(node, matcher)
+        end
+
+        def heredoc_argument?(matcher)
+          matcher.arguments.select do |arg|
+            arg.type?(:str, :dstr, :xstr)
+          end.any?(&:heredoc?)
+        end
+
+        # @!method predicate_matcher?(node)
+        def_node_matcher :predicate_matcher?, <<~PATTERN
           (send
             (send nil? :expect $!nil?)
-            #{Runners::ALL.node_pattern_union}
-            {$(send nil? #predicate_matcher_name? ...)
-              (block $(send nil? #predicate_matcher_name? ...) ...)})
+            #Runners.all
+            {
+              $(send nil? #predicate_matcher_name? ...)
+              (block $(send nil? #predicate_matcher_name? ...) ...)
+            }
+            ...
+          )
         PATTERN
 
-        def_node_matcher :predicate_matcher_block?, <<-PATTERN
+        # @!method predicate_matcher_block?(node)
+        def_node_matcher :predicate_matcher_block?, <<~PATTERN
           (block
             (send
               (send nil? :expect $!nil?)
-              #{Runners::ALL.node_pattern_union}
+              #Runners.all
               $(send nil? #predicate_matcher_name?))
             ...)
         PATTERN
@@ -184,7 +214,8 @@ def predicate_matcher_name?(name)
 
           return false if allowed_explicit_matchers.include?(name)
 
-          name.start_with?('be_', 'have_') && !name.end_with?('?')
+          (name.start_with?('be_', 'have_') && !name.end_with?('?')) ||
+            %w[include respond_to].include?(name)
         end
 
         def message_explicit(matcher)
@@ -193,75 +224,53 @@ def message_explicit(matcher)
                  matcher_name: matcher.method_name)
         end
 
-        def autocorrect_explicit(node)
-          autocorrect_explicit_send(node) ||
-            autocorrect_explicit_block(node)
-        end
-
-        def autocorrect_explicit_send(node)
-          predicate_matcher?(node) do |actual, matcher|
-            corrector_explicit(node, actual, matcher, matcher)
-          end
-        end
-
-        def autocorrect_explicit_block(node)
-          predicate_matcher_block?(node) do |actual, matcher|
-            to_node = node.send_node
-            corrector_explicit(to_node, actual, matcher, to_node)
-          end
-        end
-
-        def corrector_explicit(to_node, actual, matcher, block_child)
-          lambda do |corrector|
-            replacement_matcher = replacement_matcher(to_node)
-            corrector.replace(matcher.loc.expression, replacement_matcher)
-            move_predicate(corrector, actual, matcher, block_child)
-            corrector.replace(to_node.loc.selector, 'to')
-          end
+        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
+          replacement_matcher = replacement_matcher(to_node)
+          corrector.replace(matcher, replacement_matcher)
+          move_predicate(corrector, actual, matcher, block_child)
+          corrector.replace(to_node.loc.selector, 'to')
         end
 
         def move_predicate(corrector, actual, matcher, block_child)
           predicate = to_predicate_method(matcher.method_name)
-          args = args_loc(matcher).source
-          block_loc = block_loc(block_child)
+          args = LocationHelp.arguments_with_whitespace(matcher).source
+          block_loc = LocationHelp.block_with_whitespace(block_child)
           block = block_loc ? block_loc.source : ''
 
           corrector.remove(block_loc) if block_loc
-          corrector.insert_after(actual.loc.expression,
-                                 ".#{predicate}" + args + block)
+          corrector.insert_after(actual, ".#{predicate}" + args + block)
         end
 
-        # rubocop:disable Metrics/MethodLength
         def to_predicate_method(matcher)
           case matcher = matcher.to_s
           when 'be_a', 'be_an', 'be_a_kind_of', 'a_kind_of', 'be_kind_of'
             'is_a?'
           when 'be_an_instance_of', 'be_instance_of', 'an_instance_of'
             'instance_of?'
-          when 'include', 'respond_to'
-            matcher + '?'
-          when /^have_(.+)/
+          when 'include'
+            'include?'
+          when 'respond_to'
+            'respond_to?'
+          when /\Ahave_(.+)/
             "has_#{Regexp.last_match(1)}?"
           else
-            matcher[/^be_(.+)/, 1] + '?'
+            "#{matcher[/\Abe_(.+)/, 1]}?"
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def replacement_matcher(node)
-          case [cop_config['Strict'], node.method_name == :to]
+          case [cop_config['Strict'], node.method?(:to)]
           when [true, true]
             'be(true)'
           when [true, false]
             'be(false)'
           when [false, true]
             'be_truthy'
-          when [false, false]
+          else
             'be_falsey'
           end
         end
       end
-      # rubocop:enable Metrics/ModuleLength
 
       # Prefer using predicate matcher over using predicate method directly.
       #
@@ -277,12 +286,12 @@ def replacement_matcher(node)
       #   expect(foo).to be_something
       #
       #   # also good - It checks "true" strictly.
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       # @example Strict: false, EnforcedStyle: inflected
       #   # bad
       #   expect(foo.something?).to be_truthy
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       #   # good
       #   expect(foo).to be_something
@@ -294,63 +303,48 @@ def replacement_matcher(node)
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be(true)
       #
+      #   # bad - no autocorrect
+      #   expect(foo)
+      #     .to be_something(<<~TEXT)
+      #       bar
+      #     TEXT
+      #
+      #   # good
+      #   expect(foo.something?(<<~TEXT)).to be(true)
+      #     bar
+      #   TEXT
+      #
       # @example Strict: false, EnforcedStyle: explicit
       #   # bad
       #   expect(foo).to be_something
       #
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be_truthy
-      class PredicateMatcher < Cop
+      #
+      class PredicateMatcher < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
         include InflectedHelper
         include ExplicitHelper
 
+        RESTRICT_ON_SEND = Runners.all
+
         def on_send(node)
           case style
           when :inflected
             check_inflected(node)
           when :explicit
             check_explicit(node)
+          else
+            # :nocov:
+            :noop
+            # :nocov:
           end
         end
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check_explicit(node) if style == :explicit
         end
-
-        def autocorrect(node)
-          case style
-          when :inflected
-            autocorrect_inflected(node)
-          when :explicit
-            autocorrect_explicit(node)
-          end
-        end
-
-        private
-
-        # returns args location with whitespace
-        # @example
-        #   foo 1, 2
-        #      ^^^^^
-        def args_loc(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
-
-        # returns block location with whitespace
-        # @example
-        #   foo { bar }
-        #      ^^^^^^^^
-        def block_loc(send_node)
-          parent = send_node.parent
-          return unless parent.block_type?
-
-          send_node.loc.expression.end.with(
-            end_pos: parent.loc.expression.end_pos
-          )
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/rails/http_status.rb b/lib/rubocop/cop/rspec/rails/http_status.rb
deleted file mode 100644
index fae03385c..000000000
--- a/lib/rubocop/cop/rspec/rails/http_status.rb
+++ /dev/null
@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/utils'
-
-module RuboCop
-  module Cop
-    module RSpec
-      module Rails
-        # Enforces use of symbolic or numeric value to describe HTTP status.
-        #
-        # @example `EnforcedStyle: symbolic` (default)
-        #   # bad
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        # @example `EnforcedStyle: numeric`
-        #   # bad
-        #   it { is_expected.to have_http_status :ok }
-        #   it { is_expected.to have_http_status :not_found }
-        #
-        #   # good
-        #   it { is_expected.to have_http_status 200 }
-        #   it { is_expected.to have_http_status 404 }
-        #   it { is_expected.to have_http_status :success }
-        #   it { is_expected.to have_http_status :error }
-        #
-        class HttpStatus < Cop
-          include ConfigurableEnforcedStyle
-
-          def_node_matcher :http_status, <<-PATTERN
-            (send nil? :have_http_status ${int sym})
-          PATTERN
-
-          def on_send(node)
-            http_status(node) do |ast_node|
-              checker = checker_class.new(ast_node)
-              return unless checker.offensive?
-
-              add_offense(checker.node, message: checker.message)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              checker = checker_class.new(node)
-              corrector.replace(node.loc.expression, checker.preferred_style)
-            end
-          end
-
-          private
-
-          def checker_class
-            case style
-            when :symbolic
-              SymbolicStyleChecker
-            when :numeric
-              NumericStyleChecker
-            end
-          end
-
-          # :nodoc:
-          class SymbolicStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-
-            attr_reader :node
-            def initialize(node)
-              @node = node
-            end
-
-            def offensive?
-              !node.sym_type? && !custom_http_status_code?
-            end
-
-            def message
-              format(MSG, prefer: preferred_style, current: number.to_s)
-            end
-
-            def preferred_style
-              symbol.inspect
-            end
-
-            private
-
-            def symbol
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
-            end
-
-            def number
-              node.source.to_i
-            end
-
-            def custom_http_status_code?
-              node.int_type? &&
-                !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(node.source.to_i)
-            end
-          end
-
-          # :nodoc:
-          class NumericStyleChecker
-            MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                  'to describe HTTP status code.'
-
-            ALLOWED_STATUSES = %i[error success missing redirect].freeze
-
-            attr_reader :node
-            def initialize(node)
-              @node = node
-            end
-
-            def offensive?
-              !node.int_type? && !allowed_symbol?
-            end
-
-            def message
-              format(MSG, prefer: preferred_style, current: symbol.inspect)
-            end
-
-            def preferred_style
-              number.to_s
-            end
-
-            private
-
-            def number
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[symbol]
-            end
-
-            def symbol
-              node.value
-            end
-
-            def allowed_symbol?
-              node.sym_type? && ALLOWED_STATUSES.include?(node.value)
-            end
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/cop/rspec/receive_counts.rb b/lib/rubocop/cop/rspec/receive_counts.rb
index 184932f3e..3afc593b8 100644
--- a/lib/rubocop/cop/rspec/receive_counts.rb
+++ b/lib/rubocop/cop/rspec/receive_counts.rb
@@ -6,30 +6,35 @@ module RSpec
       # Check for `once` and `twice` receive counts matchers usage.
       #
       # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).exactly(1).times
+      #   expect(foo).to receive(:bar).exactly(2).times
+      #   expect(foo).to receive(:bar).at_least(1).times
+      #   expect(foo).to receive(:bar).at_least(2).times
+      #   expect(foo).to receive(:bar).at_most(1).times
+      #   expect(foo).to receive(:bar).at_most(2).times
       #
-      #     # bad
-      #     expect(foo).to receive(:bar).exactly(1).times
-      #     expect(foo).to receive(:bar).exactly(2).times
-      #     expect(foo).to receive(:bar).at_least(1).times
-      #     expect(foo).to receive(:bar).at_least(2).times
-      #     expect(foo).to receive(:bar).at_most(1).times
-      #     expect(foo).to receive(:bar).at_most(2).times
+      #   # good
+      #   expect(foo).to receive(:bar).once
+      #   expect(foo).to receive(:bar).twice
+      #   expect(foo).to receive(:bar).at_least(:once)
+      #   expect(foo).to receive(:bar).at_least(:twice)
+      #   expect(foo).to receive(:bar).at_most(:once)
+      #   expect(foo).to receive(:bar).at_most(:twice).times
       #
-      #     # good
-      #     expect(foo).to receive(:bar).once
-      #     expect(foo).to receive(:bar).twice
-      #     expect(foo).to receive(:bar).at_least(:once)
-      #     expect(foo).to receive(:bar).at_least(:twice)
-      #     expect(foo).to receive(:bar).at_most(:once)
-      #     expect(foo).to receive(:bar).at_most(:twice).times
-      #
-      class ReceiveCounts < Cop
+      class ReceiveCounts < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<alternative>s` instead of `%<original>s`.'
 
-        def_node_matcher :receive_counts, <<-PATTERN
+        RESTRICT_ON_SEND = %i[times].freeze
+
+        # @!method receive_counts(node)
+        def_node_matcher :receive_counts, <<~PATTERN
           (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
         PATTERN
 
+        # @!method stub?(node)
         def_node_search :stub?, '(send nil? :receive ...)'
 
         def on_send(node)
@@ -38,27 +43,23 @@ def on_send(node)
 
             offending_range = range(node, offending_node)
 
-            add_offense(
-              offending_node,
-              message: message_for(offending_node, offending_range.source),
-              location: offending_range
-            )
+            msg = message_for(offending_node, offending_range.source)
+            add_offense(offending_range, message: msg) do |corrector|
+              autocorrect(corrector, offending_node, offending_range)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = matcher_for(
-              node.method_name,
-              node.first_argument.source.to_i
-            )
+        private
 
-            original = range(node.parent, node)
-            corrector.replace(original, replacement)
-          end
-        end
+        def autocorrect(corrector, node, range)
+          replacement = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
 
-        private
+          corrector.replace(range, replacement)
+        end
 
         def message_for(node, source)
           alternative = matcher_for(
@@ -79,7 +80,7 @@ def matcher_for(method, count)
 
         def range(node, offending_node)
           offending_node.loc.dot.with(
-            end_pos: node.loc.expression.end_pos
+            end_pos: node.source_range.end_pos
           )
         end
       end
diff --git a/lib/rubocop/cop/rspec/receive_messages.rb b/lib/rubocop/cop/rspec/receive_messages.rb
new file mode 100644
index 000000000..4c1447ce8
--- /dev/null
+++ b/lib/rubocop/cop/rspec/receive_messages.rb
@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Prefer `receive_messages` over multiple `receive`s on the same object.
+      #
+      # @safety
+      #   The autocorrection is marked as unsafe, because it may change the
+      #   order of stubs. This in turn may cause e.g. variables to be called
+      #   before they are defined.
+      #
+      # @example
+      #   # bad
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:baz).and_return(qux)
+      #   end
+      #
+      #   # good
+      #   before do
+      #     allow(Service).to receive_messages(foo: bar, baz: qux)
+      #   end
+      #
+      #   # good - ignore same message
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:foo).and_return(qux)
+      #   end
+      #
+      class ReceiveMessages < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `receive_messages` instead of multiple stubs on lines ' \
+              '%<loc>s.'
+
+        # @!method allow_receive_message?(node)
+        def_node_matcher :allow_receive_message?, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym _)) :and_return !#heredoc_or_splat?))
+        PATTERN
+
+        # @!method allow_argument(node)
+        def_node_matcher :allow_argument, <<~PATTERN
+          (send (send nil? :allow $_ ...) ...)
+        PATTERN
+
+        # @!method receive_node(node)
+        def_node_search :receive_node, <<~PATTERN
+          $(send (send nil? :receive ...) ...)
+        PATTERN
+
+        # @!method receive_arg(node)
+        def_node_search :receive_arg, <<~PATTERN
+          (send (send nil? :receive $_) ...)
+        PATTERN
+
+        # @!method receive_and_return_argument(node)
+        def_node_matcher :receive_and_return_argument, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym $_)) :and_return $_))
+        PATTERN
+
+        def on_begin(node)
+          repeated_receive_message(node).each do |item, repeated_lines, args|
+            next if repeated_lines.empty?
+
+            register_offense(item, repeated_lines, args)
+          end
+        end
+
+        private
+
+        def repeated_receive_message(node)
+          node
+            .children
+            .select { |child| allow_receive_message?(child) }
+            .group_by { |child| allow_argument(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines_and_arguments(items) }
+        end
+
+        def add_repeated_lines_and_arguments(items)
+          uniq_items = uniq_items(items)
+          repeated_lines = uniq_items.map(&:first_line)
+          uniq_items.map do |item|
+            [item, repeated_lines - [item.first_line], arguments(uniq_items)]
+          end
+        end
+
+        def uniq_items(items)
+          items.select do |item|
+            items.none? do |i|
+              receive_arg(item).first == receive_arg(i).first &&
+                !same_line?(item, i)
+            end
+          end
+        end
+
+        def arguments(items)
+          items.map do |item|
+            receive_and_return_argument(item) do |receive_arg, return_arg|
+              "#{normalize_receive_arg(receive_arg)}: " \
+                "#{normalize_return_arg(return_arg)}"
+            end
+          end
+        end
+
+        def normalize_receive_arg(receive_arg)
+          if requires_quotes?(receive_arg)
+            "'#{receive_arg}'"
+          else
+            receive_arg
+          end
+        end
+
+        def normalize_return_arg(return_arg)
+          if return_arg.hash_type? && !return_arg.braces?
+            "{ #{return_arg.source} }"
+          else
+            return_arg.source
+          end
+        end
+
+        def register_offense(item, repeated_lines, args)
+          add_offense(item, message: message(repeated_lines)) do |corrector|
+            if item.loc.line > repeated_lines.max
+              replace_to_receive_messages(corrector, item, args)
+            else
+              corrector.remove(item_range_by_whole_lines(item))
+            end
+          end
+        end
+
+        def message(repeated_lines)
+          format(MSG, loc: repeated_lines)
+        end
+
+        def replace_to_receive_messages(corrector, item, args)
+          receive_node(item) do |node|
+            corrector.replace(node,
+                              "receive_messages(#{args.join(', ')})")
+          end
+        end
+
+        def item_range_by_whole_lines(item)
+          range_by_whole_lines(item.source_range, include_final_newline: true)
+        end
+
+        def heredoc_or_splat?(node)
+          (node.type?(:str, :dstr) && node.heredoc?) || node.splat_type?
+        end
+
+        def requires_quotes?(value)
+          value.match?(/^:".*?"|=$|^\W+$/)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/receive_never.rb b/lib/rubocop/cop/rspec/receive_never.rb
index 1f8975e1e..aeb9f87ad 100644
--- a/lib/rubocop/cop/rspec/receive_never.rb
+++ b/lib/rubocop/cop/rspec/receive_never.rb
@@ -6,33 +6,34 @@ module RSpec
       # Prefer `not_to receive(...)` over `receive(...).never`.
       #
       # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).never
       #
-      #     # bad
-      #     expect(foo).to receive(:bar).never
+      #   # good
+      #   expect(foo).not_to receive(:bar)
       #
-      #     # good
-      #     expect(foo).not_to receive(:bar)
-      #
-      class ReceiveNever < Cop
+      class ReceiveNever < Base
+        extend AutoCorrector
         MSG = 'Use `not_to receive` instead of `never`.'
+        RESTRICT_ON_SEND = %i[never].freeze
 
+        # @!method method_on_stub?(node)
         def_node_search :method_on_stub?, '(send nil? :receive ...)'
 
         def on_send(node)
-          return unless node.method_name == :never && method_on_stub?(node)
+          return unless node.method?(:never) && method_on_stub?(node)
 
-          add_offense(
-            node,
-            location: :selector
-          )
+          add_offense(node.loc.selector) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.selector, 'not_to')
-            range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
+          corrector.remove(range)
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/redundant_around.rb b/lib/rubocop/cop/rspec/redundant_around.rb
new file mode 100644
index 000000000..7522c9ce0
--- /dev/null
+++ b/lib/rubocop/cop/rspec/redundant_around.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Remove redundant `around` hook.
+      #
+      # @example
+      #   # bad
+      #   around do |example|
+      #     example.run
+      #   end
+      #
+      #   # good
+      #
+      class RedundantAround < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `around` hook.'
+
+        RESTRICT_ON_SEND = %i[around].freeze
+
+        def on_block(node)
+          return unless match_redundant_around_hook_block?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless match_redundant_around_hook_send?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method match_redundant_around_hook_block?(node)
+        def_node_matcher :match_redundant_around_hook_block?, <<~PATTERN
+          (any_block (send _ :around ...) ... (send _ :run))
+        PATTERN
+
+        # @!method match_redundant_around_hook_send?(node)
+        def_node_matcher :match_redundant_around_hook_send?, <<~PATTERN
+          (send
+            _
+            :around
+            ...
+            (block-pass
+              (sym :run)
+            )
+          )
+        PATTERN
+
+        def autocorrect(corrector, node)
+          corrector.remove(node)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/redundant_predicate_matcher.rb b/lib/rubocop/cop/rspec/redundant_predicate_matcher.rb
new file mode 100644
index 000000000..f04992e5d
--- /dev/null
+++ b/lib/rubocop/cop/rspec/redundant_predicate_matcher.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for redundant predicate matcher.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be_exist(bar)
+      #   expect(foo).not_to be_include(bar)
+      #   expect(foo).to be_all(bar)
+      #
+      #   # good
+      #   expect(foo).to exist(bar)
+      #   expect(foo).not_to include(bar)
+      #   expect(foo).to all be(bar)
+      #
+      class RedundantPredicateMatcher < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND =
+          %i[be_all be_cover be_end_with be_eql be_equal
+             be_exist be_exists be_include be_match
+             be_respond_to be_start_with].freeze
+
+        def on_send(node)
+          return if node.parent.block_type? || node.arguments.empty?
+          return unless replaceable_arguments?(node)
+
+          method_name = node.method_name.to_s
+          replaced = replaced_method_name(method_name)
+          add_offense(node, message: message(method_name,
+                                             replaced)) do |corrector|
+            unless node.method?(:be_all)
+              corrector.replace(node.loc.selector, replaced)
+            end
+          end
+        end
+
+        private
+
+        def message(bad_method, good_method)
+          format(MSG, bad: bad_method, good: good_method)
+        end
+
+        def replaceable_arguments?(node)
+          if node.method?(:be_all)
+            node.first_argument.send_type?
+          else
+            true
+          end
+        end
+
+        def replaced_method_name(method_name)
+          name = method_name.to_s.delete_prefix('be_')
+          if name == 'exists'
+            'exist'
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/remove_const.rb b/lib/rubocop/cop/rspec/remove_const.rb
new file mode 100644
index 000000000..a2fe1475d
--- /dev/null
+++ b/lib/rubocop/cop/rspec/remove_const.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that `remove_const` is not used in specs.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     Object.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      #   before do
+      #     SomeClass.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      class RemoveConst < Base
+        include RuboCop::RSpec::Language
+
+        MSG = 'Do not use remove_const in specs. ' \
+              'Consider using e.g. `stub_const`.'
+        RESTRICT_ON_SEND = %i[send __send__].freeze
+
+        # @!method remove_const(node)
+        def_node_matcher :remove_const, <<~PATTERN
+          (send _ {:send | :__send__} (sym :remove_const) _)
+        PATTERN
+
+        # Check for offenses
+        def on_send(node)
+          remove_const(node) do
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/repeated_description.rb b/lib/rubocop/cop/rspec/repeated_description.rb
index 36b79973b..c7f90068d 100644
--- a/lib/rubocop/cop/rspec/repeated_description.rb
+++ b/lib/rubocop/cop/rspec/repeated_description.rb
@@ -6,48 +6,51 @@ module RSpec
       # Check for repeated description strings in example groups.
       #
       # @example
+      #   # bad
+      #   RSpec.describe User do
+      #     it 'is valid' do
+      #       # ...
+      #     end
       #
-      #     # bad
-      #     RSpec.describe User do
-      #       it 'is valid' do
-      #         # ...
-      #       end
-      #
-      #       it 'is valid' do
-      #         # ...
-      #       end
+      #     it 'is valid' do
+      #       # ...
       #     end
+      #   end
       #
-      #     # good
-      #     RSpec.describe User do
-      #       it 'is valid when first and last name are present' do
-      #         # ...
-      #       end
+      #   # good
+      #   RSpec.describe User do
+      #     it 'is valid when first and last name are present' do
+      #       # ...
+      #     end
       #
-      #       it 'is valid when last name only is present' do
-      #         # ...
-      #       end
+      #     it 'is valid when last name only is present' do
+      #       # ...
       #     end
+      #   end
       #
-      #     # good
-      #     RSpec.describe User do
-      #       it 'is valid' do
-      #         # ...
-      #       end
+      #   # good
+      #   RSpec.describe User do
+      #     it 'is valid' do
+      #       # ...
+      #     end
       #
-      #       it 'is valid', :flag do
-      #         # ...
-      #       end
+      #     it 'is valid', :flag do
+      #       # ...
       #     end
+      #   end
       #
-      class RepeatedDescription < Cop
+      class RepeatedDescription < Base
         MSG = "Don't repeat descriptions within an example group."
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group?(node)
 
-          repeated_descriptions(node).each do |repeated_description|
-            add_offense(repeated_description)
+          repeated_descriptions(node).each do |description|
+            add_offense(description)
+          end
+
+          repeated_its(node).each do |its|
+            add_offense(its)
           end
         end
 
@@ -58,6 +61,7 @@ def repeated_descriptions(node)
           grouped_examples =
             RuboCop::RSpec::ExampleGroup.new(node)
               .examples
+              .reject { |n| n.definition.method?(:its) }
               .group_by { |example| example_signature(example) }
 
           grouped_examples
@@ -67,9 +71,27 @@ def repeated_descriptions(node)
             .map(&:definition)
         end
 
+        def repeated_its(node)
+          grouped_its =
+            RuboCop::RSpec::ExampleGroup.new(node)
+              .examples
+              .select { |n| n.definition.method?(:its) }
+              .group_by { |example| its_signature(example) }
+
+          grouped_its
+            .select { |signatures, group| signatures.any? && group.size > 1 }
+            .values
+            .flatten
+            .map(&:to_node)
+        end
+
         def example_signature(example)
           [example.metadata, example.doc_string]
         end
+
+        def its_signature(example)
+          [example.doc_string, example]
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/repeated_example.rb b/lib/rubocop/cop/rspec/repeated_example.rb
index 9dce0ea15..c8e5665bb 100644
--- a/lib/rubocop/cop/rspec/repeated_example.rb
+++ b/lib/rubocop/cop/rspec/repeated_example.rb
@@ -7,18 +7,18 @@ module RSpec
       #
       # @example
       #
-      #    it 'is valid' do
-      #      expect(user).to be_valid
-      #    end
+      #   it 'is valid' do
+      #     expect(user).to be_valid
+      #   end
       #
-      #    it 'validates the user' do
-      #      expect(user).to be_valid
-      #    end
+      #   it 'validates the user' do
+      #     expect(user).to be_valid
+      #   end
       #
-      class RepeatedExample < Cop
+      class RepeatedExample < Base
         MSG = "Don't repeat examples within an example group."
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group?(node)
 
           repeated_examples(node).each do |repeated_example|
@@ -41,7 +41,7 @@ def repeated_examples(node)
         def example_signature(example)
           key_parts = [example.metadata, example.implementation]
 
-          if example.definition.method_name == :its
+          if example.definition.method?(:its)
             key_parts << example.definition.arguments
           end
 
diff --git a/lib/rubocop/cop/rspec/repeated_example_group_body.rb b/lib/rubocop/cop/rspec/repeated_example_group_body.rb
index ab55a509f..9e2fc6fb5 100644
--- a/lib/rubocop/cop/rspec/repeated_example_group_body.rb
+++ b/lib/rubocop/cop/rspec/repeated_example_group_body.rb
@@ -6,47 +6,60 @@ module RSpec
       # Check for repeated describe and context block body.
       #
       # @example
+      #   # bad
+      #   describe 'cool feature x' do
+      #     it { cool_predicate }
+      #   end
       #
-      #    # bad
-      #    describe 'cool feature x' do
-      #      it { cool_predicate }
-      #    end
+      #   describe 'cool feature y' do
+      #     it { cool_predicate }
+      #   end
       #
-      #    describe 'cool feature y' do
-      #      it { cool_predicate }
-      #    end
+      #   # good
+      #   describe 'cool feature' do
+      #     it { cool_predicate }
+      #   end
       #
-      #    # good
-      #    describe 'cool feature' do
-      #      it { cool_predicate }
-      #    end
+      #   describe 'another cool feature' do
+      #     it { another_predicate }
+      #   end
       #
-      #    describe 'another cool feature' do
-      #      it { another_predicate }
-      #    end
+      #   # good
+      #   context 'when case x', :tag do
+      #     it { cool_predicate }
+      #   end
       #
-      #    # good
-      #    context 'when case x', :tag do
-      #      it { cool_predicate }
-      #    end
+      #   context 'when case y' do
+      #     it { cool_predicate }
+      #   end
       #
-      #    context 'when case y' do
-      #      it { cool_predicate }
-      #    end
+      #   # good
+      #   context Array do
+      #     it { is_expected.to respond_to :each }
+      #   end
       #
-      class RepeatedExampleGroupBody < Cop
+      #   context Hash do
+      #     it { is_expected.to respond_to :each }
+      #   end
+      #
+      class RepeatedExampleGroupBody < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        # @!method several_example_groups?(node)
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group_with_body? #example_group_with_body? ...>)
         PATTERN
 
+        # @!method metadata(node)
         def_node_matcher :metadata, '(block (send _ _ _ $...) ...)'
+
+        # @!method body(node)
         def_node_matcher :body, '(block _ args $...)'
 
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending}) ...>)
-        PATTERN
+        # @!method const_arg(node)
+        def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
 
         def on_begin(node)
           return unless several_example_groups?(node)
@@ -62,7 +75,7 @@ def repeated_group_bodies(node)
           node
             .children
             .select { |child| example_group_with_body?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .group_by { |group| signature_keys(group) }
             .values
             .reject(&:one?)
@@ -75,7 +88,7 @@ def add_repeated_lines(groups)
         end
 
         def signature_keys(group)
-          [metadata(group), body(group)]
+          [metadata(group), body(group), const_arg(group)]
         end
 
         def message(group, repeats)
diff --git a/lib/rubocop/cop/rspec/repeated_example_group_description.rb b/lib/rubocop/cop/rspec/repeated_example_group_description.rb
index 17da2b5cf..1e534141d 100644
--- a/lib/rubocop/cop/rspec/repeated_example_group_description.rb
+++ b/lib/rubocop/cop/rspec/repeated_example_group_description.rb
@@ -6,58 +6,58 @@ module RSpec
       # Check for repeated example group descriptions.
       #
       # @example
+      #   # bad
+      #   describe 'cool feature' do
+      #     # example group
+      #   end
       #
-      #    # bad
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
+      #   describe 'cool feature' do
+      #     # example group
+      #   end
       #
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
+      #   # bad
+      #   context 'when case x' do
+      #     # example group
+      #   end
       #
-      #    # bad
-      #    context 'when case x' do
-      #      # example group
-      #    end
+      #   describe 'when case x' do
+      #     # example group
+      #   end
       #
-      #    describe 'when case x' do
-      #      # example group
-      #    end
+      #   # good
+      #   describe 'cool feature' do
+      #     # example group
+      #   end
       #
-      #    # good
-      #    describe 'cool feature' do
-      #      # example group
-      #    end
+      #   describe 'another cool feature' do
+      #     # example group
+      #   end
       #
-      #    describe 'another cool feature' do
-      #      # example group
-      #    end
+      #   # good
+      #   context 'when case x' do
+      #     # example group
+      #   end
       #
-      #    # good
-      #    context 'when case x' do
-      #      # example group
-      #    end
+      #   context 'when another case' do
+      #     # example group
+      #   end
       #
-      #    context 'when another case' do
-      #      # example group
-      #    end
-      #
-      class RepeatedExampleGroupDescription < Cop
+      class RepeatedExampleGroupDescription < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        # @!method several_example_groups?(node)
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group? #example_group? ...>)
         PATTERN
 
-        def_node_matcher :doc_string_and_metadata, <<-PATTERN
+        # @!method doc_string_and_metadata(node)
+        def_node_matcher :doc_string_and_metadata, <<~PATTERN
           (block (send _ _ $_ $...) ...)
         PATTERN
 
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending}) ...>)
-        PATTERN
-
+        # @!method empty_description?(node)
         def_node_matcher :empty_description?, '(block (send _ _) ...)'
 
         def on_begin(node)
@@ -74,7 +74,7 @@ def repeated_group_descriptions(node)
           node
             .children
             .select { |child| example_group?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .reject { |child| empty_description?(child) }
             .group_by { |group| doc_string_and_metadata(group) }
             .values
diff --git a/lib/rubocop/cop/rspec/repeated_include_example.rb b/lib/rubocop/cop/rspec/repeated_include_example.rb
new file mode 100644
index 000000000..811387411
--- /dev/null
+++ b/lib/rubocop/cop/rspec/repeated_include_example.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated include of shared examples.
+      #
+      # @example
+      #   # bad
+      #   describe 'foo' do
+      #     include_examples 'cool stuff'
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   # bad
+      #   describe 'foo' do
+      #     it_behaves_like 'a cool', 'thing'
+      #     it_behaves_like 'a cool', 'thing'
+      #   end
+      #
+      #   # bad
+      #   context 'foo' do
+      #     it_should_behave_like 'a duck'
+      #     it_should_behave_like 'a duck'
+      #   end
+      #
+      #   # good
+      #   describe 'foo' do
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   describe 'bar' do
+      #     include_examples 'cool stuff'
+      #   end
+      #
+      #   # good
+      #   describe 'foo' do
+      #     it_behaves_like 'a cool', 'thing'
+      #     it_behaves_like 'a cool', 'person'
+      #   end
+      #
+      #   # good
+      #   context 'foo' do
+      #     it_should_behave_like 'a duck'
+      #     it_should_behave_like 'a goose'
+      #   end
+      #
+      class RepeatedIncludeExample < Base
+        MSG = 'Repeated include of shared_examples %<name>s ' \
+              'on line(s) %<repeat>s'
+
+        # @!method several_include_examples?(node)
+        def_node_matcher :several_include_examples?, <<~PATTERN
+          (begin <#include_examples? #include_examples? ...>)
+        PATTERN
+
+        # @!method include_examples?(node)
+        def_node_matcher :include_examples?,
+                         '(send nil? #Includes.examples ...)'
+
+        # @!method shared_examples_name(node)
+        def_node_matcher :shared_examples_name,
+                         '(send nil? #Includes.examples $_name ...)'
+
+        def on_begin(node)
+          return unless several_include_examples?(node)
+
+          repeated_include_examples(node).each do |item, repeats|
+            add_offense(item, message: message(item, repeats))
+          end
+        end
+
+        private
+
+        def repeated_include_examples(node)
+          node
+            .children
+            .select { |child| literal_include_examples?(child) }
+            .group_by { |child| signature_keys(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines(items) }
+        end
+
+        def literal_include_examples?(node)
+          include_examples?(node) &&
+            node.arguments.all?(&:recursive_literal_or_const?)
+        end
+
+        def add_repeated_lines(items)
+          repeated_lines = items.map(&:first_line)
+          items.map { |item| [item, repeated_lines - [item.first_line]] }
+        end
+
+        def signature_keys(item)
+          item.arguments
+        end
+
+        def message(item, repeats)
+          format(MSG, name: shared_examples_name(item).source, repeat: repeats)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/repeated_subject_call.rb b/lib/rubocop/cop/rspec/repeated_subject_call.rb
new file mode 100644
index 000000000..15bcffc60
--- /dev/null
+++ b/lib/rubocop/cop/rspec/repeated_subject_call.rb
@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for repeated calls to subject missing that it is memoized.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     subject
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   it do
+      #     expect { subject }.to change { A.count }
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect { my_method }.to change { A.count }
+      #     expect { my_method }.to not_change { A.count }
+      #   end
+      #
+      #   # also good
+      #   it do
+      #     expect { subject.a }.to change { A.count }
+      #     expect { subject.b }.to not_change { A.count }
+      #   end
+      #
+      class RepeatedSubjectCall < Base
+        include TopLevelGroup
+
+        MSG = 'Calls to subject are memoized, this block is misleading'
+
+        # @!method subject?(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject?(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method subject_calls(node, method_name)
+        def_node_search :subject_calls, <<~PATTERN
+          (send nil? %)
+        PATTERN
+
+        def on_top_level_group(node)
+          @subjects_by_node = detect_subjects_in_scope(node)
+
+          detect_offenses_in_block(node)
+        end
+
+        private
+
+        def detect_offense(subject_node)
+          return if subject_node.chained?
+          return if subject_node.parent.send_type?
+          return unless (block_node = expect_block(subject_node))
+
+          add_offense(block_node)
+        end
+
+        def expect_block(node)
+          node.each_ancestor(:block).find { |block| block.method?(:expect) }
+        end
+
+        def detect_offenses_in_block(node, subject_names = [])
+          subject_names = [*subject_names, *@subjects_by_node[node]]
+
+          if example?(node)
+            return detect_offenses_in_example(node, subject_names)
+          end
+
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            detect_offenses_in_block(child, subject_names)
+          end
+        end
+
+        def detect_offenses_in_example(node, subject_names)
+          return unless node.body
+
+          subjects_used = Hash.new(false)
+
+          subject_calls(node.body, Set[*subject_names, :subject]).each do |call|
+            if subjects_used[call.method_name]
+              detect_offense(call)
+            else
+              subjects_used[call.method_name] = true
+            end
+          end
+        end
+
+        def detect_subjects_in_scope(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            subject?(child) do |name|
+              outer_example_group = child.each_ancestor(:block).find do |a|
+                example_group?(a)
+              end
+
+              (h[outer_example_group] ||= []) << name
+            end
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/return_from_stub.rb b/lib/rubocop/cop/rspec/return_from_stub.rb
index 1888fc48f..80f39b9fc 100644
--- a/lib/rubocop/cop/rspec/return_from_stub.rb
+++ b/lib/rubocop/cop/rspec/return_from_stub.rb
@@ -11,6 +11,17 @@ module RSpec
       #
       # This cop can be configured using the `EnforcedStyle` option
       #
+      # @example `EnforcedStyle: and_return` (default)
+      #   # bad
+      #   allow(Foo).to receive(:bar) { "baz" }
+      #   expect(Foo).to receive(:bar) { "baz" }
+      #
+      #   # good
+      #   allow(Foo).to receive(:bar).and_return("baz")
+      #   expect(Foo).to receive(:bar).and_return("baz")
+      #   # also good as the returned value is dynamic
+      #   allow(Foo).to receive(:bar) { bar.baz }
+      #
       # @example `EnforcedStyle: block`
       #   # bad
       #   allow(Foo).to receive(:bar).and_return("baz")
@@ -22,72 +33,57 @@ module RSpec
       #   # also good as the returned value is dynamic
       #   allow(Foo).to receive(:bar).and_return(bar.baz)
       #
-      # @example `EnforcedStyle: and_return`
-      #   # bad
-      #   allow(Foo).to receive(:bar) { "baz" }
-      #   expect(Foo).to receive(:bar) { "baz" }
-      #
-      #   # good
-      #   allow(Foo).to receive(:bar).and_return("baz")
-      #   expect(Foo).to receive(:bar).and_return("baz")
-      #   # also good as the returned value is dynamic
-      #   allow(Foo).to receive(:bar) { bar.baz }
-      #
-      class ReturnFromStub < Cop
+      class ReturnFromStub < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG_AND_RETURN = 'Use `and_return` for static values.'
         MSG_BLOCK = 'Use block for static values.'
+        RESTRICT_ON_SEND = %i[and_return].freeze
 
+        # @!method contains_stub?(node)
         def_node_search :contains_stub?, '(send nil? :receive (...))'
-        def_node_search :and_return_value, <<-PATTERN
+
+        # @!method stub_with_block?(node)
+        def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
+
+        # @!method and_return_value(node)
+        def_node_search :and_return_value, <<~PATTERN
           $(send _ :and_return $(...))
         PATTERN
 
         def on_send(node)
-          return unless contains_stub?(node)
           return unless style == :block
+          return unless contains_stub?(node)
 
           check_and_return_call(node)
         end
 
-        def on_block(node)
-          return unless contains_stub?(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless style == :and_return
+          return unless stub_with_block?(node)
 
           check_block_body(node)
         end
 
-        def autocorrect(node)
-          if style == :block
-            AndReturnCallCorrector.new(node)
-          else
-            BlockBodyCorrector.new(node)
-          end
-        end
-
         private
 
         def check_and_return_call(node)
           and_return_value(node) do |and_return, args|
             unless dynamic?(args)
-              add_offense(
-                and_return,
-                location: :selector,
-                message: MSG_BLOCK
-              )
+              add_offense(and_return.loc.selector, message: MSG_BLOCK) do |corr|
+                AndReturnCallCorrector.new(and_return).call(corr)
+              end
             end
           end
         end
 
         def check_block_body(block)
           body = block.body
-          unless dynamic?(body) # rubocop:disable Style/GuardClause
-            add_offense(
-              block,
-              location: :begin,
-              message: MSG_AND_RETURN
-            )
+          return if dynamic?(body)
+
+          add_offense(block.loc.begin, message: MSG_AND_RETURN) do |corrector|
+            BlockBodyCorrector.new(block).call(corrector)
           end
         end
 
@@ -152,7 +148,7 @@ def call(corrector)
             return if heredoc?
 
             corrector.replace(
-              block.loc.expression,
+              block,
               "#{block.send_node.source}.and_return(#{body.source})"
             )
           end
@@ -166,6 +162,7 @@ def heredoc?
           end
 
           NULL_BLOCK_BODY = Struct.new(:loc, :source).new(nil, 'nil')
+          private_constant :NULL_BLOCK_BODY
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/scattered_let.rb b/lib/rubocop/cop/rspec/scattered_let.rb
index b707e048c..9b89c6b18 100644
--- a/lib/rubocop/cop/rspec/scattered_let.rb
+++ b/lib/rubocop/cop/rspec/scattered_let.rb
@@ -26,10 +26,12 @@ module RSpec
       #     let!(:baz) { 3 }
       #   end
       #
-      class ScatteredLet < Cop
+      class ScatteredLet < Base
+        extend AutoCorrector
+
         MSG = 'Group all let/let! blocks in the example group together.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 
           check_let_declarations(node.body)
@@ -44,7 +46,11 @@ def check_let_declarations(body)
           lets.each_with_index do |node, idx|
             next if node.sibling_index == first_let.sibling_index + idx
 
-            add_offense(node)
+            add_offense(node) do |corrector|
+              RuboCop::RSpec::Corrector::MoveNode.new(
+                node, corrector, processed_source
+              ).move_after(first_let)
+            end
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/scattered_setup.rb b/lib/rubocop/cop/rspec/scattered_setup.rb
index f54a0a482..00f9f383e 100644
--- a/lib/rubocop/cop/rspec/scattered_setup.rb
+++ b/lib/rubocop/cop/rspec/scattered_setup.rb
@@ -5,7 +5,9 @@ module Cop
     module RSpec
       # Checks for setup scattered across multiple hooks in an example group.
       #
-      # Unify `before`, `after`, and `around` hooks when possible.
+      # Unify `before` and `after` hooks when possible.
+      # However, `around` hooks are allowed to be defined multiple times,
+      # as unifying them would typically make the code harder to read.
       #
       # @example
       #   # bad
@@ -22,29 +24,39 @@ module RSpec
       #     end
       #   end
       #
-      class ScatteredSetup < Cop
-        MSG = 'Do not define multiple `%<hook_name>s` hooks in the same '\
+      #   # good
+      #   describe Foo do
+      #     around { |example| before1; example.call; after1 }
+      #     around { |example| before2; example.call; after2 }
+      #   end
+      #
+      class ScatteredSetup < Base
+        include FinalEndLocation
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not define multiple `%<hook_name>s` hooks in the same ' \
               'example group (also defined on %<lines>s).'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group?(node)
 
           repeated_hooks(node).each do |occurrences|
-            lines = occurrences.map(&:first_line)
-
             occurrences.each do |occurrence|
-              lines_except_current = lines - [occurrence.first_line]
-              message = format(MSG, hook_name: occurrences.first.method_name,
-                               lines: lines_msg(lines_except_current))
-              add_offense(occurrence, message: message)
+              message = message(occurrences, occurrence)
+              add_offense(occurrence, message: message) do |corrector|
+                autocorrect(corrector, occurrences.first, occurrence)
+              end
             end
           end
         end
 
+        private
+
         def repeated_hooks(node)
           hooks = RuboCop::RSpec::ExampleGroup.new(node)
             .hooks
-            .select(&:knowable_scope?)
+            .select { |hook| hook.knowable_scope? && hook.name != :around }
             .group_by { |hook| [hook.name, hook.scope, hook.metadata] }
             .values
             .reject(&:one?)
@@ -61,6 +73,27 @@ def lines_msg(numbers)
             "lines #{numbers.join(', ')}"
           end
         end
+
+        def message(occurrences, occurrence)
+          lines = occurrences.map(&:first_line)
+          lines_except_current = lines - [occurrence.first_line]
+          format(MSG, hook_name: occurrences.first.method_name,
+                      lines: lines_msg(lines_except_current))
+        end
+
+        def autocorrect(corrector, first_occurrence, occurrence)
+          return if first_occurrence == occurrence || !first_occurrence.body
+
+          # Take heredocs into account
+          body = occurrence.body&.source_range&.with(
+            end_pos: final_end_location(occurrence).begin_pos
+          )
+
+          corrector.insert_after(first_occurrence.body,
+                                 "\n#{body&.source}")
+          corrector.remove(range_by_whole_lines(occurrence.source_range,
+                                                include_final_newline: true))
+        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/shared_context.rb b/lib/rubocop/cop/rspec/shared_context.rb
index d1815f0cd..4109e7819 100644
--- a/lib/rubocop/cop/rspec/shared_context.rb
+++ b/lib/rubocop/cop/rspec/shared_context.rb
@@ -50,40 +50,44 @@ module RSpec
       #     end
       #   end
       #
-      class SharedContext < Cop
-        MSG_EXAMPLES = "Use `shared_examples` when you don't "\
-                       'define context.'
+      class SharedContext < Base
+        extend AutoCorrector
 
-        MSG_CONTEXT  = "Use `shared_context` when you don't "\
-                       'define examples.'
+        MSG_EXAMPLES = "Use `shared_examples` when you don't define context."
+        MSG_CONTEXT  = "Use `shared_context` when you don't define examples."
 
-        examples = (Examples::ALL + Includes::EXAMPLES)
-        def_node_search :examples?, examples.send_pattern
+        # @!method examples?(node)
+        def_node_search :examples?, <<~PATTERN
+          (send nil? {#Includes.examples #Examples.all} ...)
+        PATTERN
 
-        context = (Hooks::ALL + Helpers::ALL + Includes::CONTEXT + Subject::ALL)
-        def_node_search :context?, context.send_pattern
+        # @!method context?(node)
+        def_node_search :context?, <<~PATTERN
+          (send nil?
+            {#Subjects.all #Helpers.all #Includes.context #Hooks.all} ...
+          )
+        PATTERN
+
+        # @!method shared_context(node)
+        def_node_matcher :shared_context, <<~PATTERN
+          (block (send #rspec? #SharedGroups.context ...) ...)
+        PATTERN
 
-        def_node_matcher :shared_context, SharedGroups::CONTEXT.block_pattern
-        def_node_matcher :shared_example, SharedGroups::EXAMPLES.block_pattern
+        # @!method shared_example(node)
+        def_node_matcher :shared_example, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
+        PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           context_with_only_examples(node) do
-            add_shared_item_offense(node.send_node, MSG_EXAMPLES)
+            add_offense(node.send_node, message: MSG_EXAMPLES) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_examples')
+            end
           end
 
           examples_with_only_context(node) do
-            add_shared_item_offense(node.send_node, MSG_CONTEXT)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            context_with_only_examples(node.parent) do
-              corrector.replace(node.loc.selector, 'shared_examples')
-            end
-
-            examples_with_only_context(node.parent) do
-              corrector.replace(node.loc.selector, 'shared_context')
+            add_offense(node.send_node, message: MSG_CONTEXT) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_context')
             end
           end
         end
@@ -97,13 +101,6 @@ def context_with_only_examples(node)
         def examples_with_only_context(node)
           shared_example(node) { yield if context?(node) && !examples?(node) }
         end
-
-        def add_shared_item_offense(node, message)
-          add_offense(
-            node,
-            message: message
-          )
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/shared_examples.rb b/lib/rubocop/cop/rspec/shared_examples.rb
index 5395d1b84..7e1ab3008 100644
--- a/lib/rubocop/cop/rspec/shared_examples.rb
+++ b/lib/rubocop/cop/rspec/shared_examples.rb
@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module RSpec
-      # Enforces use of string to titleize shared examples.
+      # Checks for consistent style for shared example names.
       #
-      # @example
+      # Enforces either `string` or `symbol` for shared example names.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: string` (default)
       #   # bad
       #   it_behaves_like :foo_bar_baz
       #   it_should_behave_like :foo_bar_baz
@@ -20,54 +24,99 @@ module RSpec
       #   shared_examples_for 'foo bar baz'
       #   include_examples 'foo bar baz'
       #
-      class SharedExamples < Cop
-        def_node_matcher :shared_examples,
-                         (SharedGroups::ALL + Includes::ALL).send_pattern
+      # @example `EnforcedStyle: symbol`
+      #   # bad
+      #   it_behaves_like 'foo bar baz'
+      #   it_should_behave_like 'foo bar baz'
+      #   shared_examples 'foo bar baz'
+      #   shared_examples_for 'foo bar baz'
+      #   include_examples 'foo bar baz'
+      #
+      #   # good
+      #   it_behaves_like :foo_bar_baz
+      #   it_should_behave_like :foo_bar_baz
+      #   shared_examples :foo_bar_baz
+      #   shared_examples_for :foo_bar_baz
+      #   include_examples :foo_bar_baz
+      #
+      class SharedExamples < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+
+        # @!method shared_examples(node)
+        def_node_matcher :shared_examples, <<~PATTERN
+          {
+            (send #rspec? #SharedGroups.all $_ ...)
+            (send nil? #Includes.all $_ ...)
+          }
+        PATTERN
 
         def on_send(node)
-          shared_examples(node) do
-            ast_node = node.first_argument
-            next unless ast_node&.sym_type?
+          shared_examples(node) do |ast_node|
+            next unless offense?(ast_node)
 
-            checker = Checker.new(ast_node)
-            add_offense(checker.node, message: checker.message)
+            checker = new_checker(ast_node)
+            add_offense(ast_node, message: checker.message) do |corrector|
+              corrector.replace(ast_node, checker.preferred_style)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = Checker.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
+        private
+
+        def offense?(ast_node)
+          if style == :symbol
+            ast_node.str_type?
+          else # string
+            ast_node.sym_type?
+          end
+        end
+
+        def new_checker(ast_node)
+          if style == :symbol
+            SymbolChecker.new(ast_node)
+          else # string
+            StringChecker.new(ast_node)
           end
         end
 
         # :nodoc:
-        class Checker
+        class SymbolChecker
           MSG = 'Prefer %<prefer>s over `%<current>s` ' \
-                'to titleize shared examples.'
+                'to symbolize shared examples.'
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end
 
           def message
-            format(MSG, prefer: preferred_style, current: symbol.inspect)
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
           end
 
           def preferred_style
-            string = symbol.to_s.tr('_', ' ')
-            wrap_with_single_quotes(string)
+            ":#{node.value.to_s.downcase.tr(' ', '_')}"
           end
+        end
 
-          private
+        # :nodoc:
+        class StringChecker
+          MSG = 'Prefer %<prefer>s over `%<current>s` ' \
+                'to titleize shared examples.'
 
-          def symbol
-            node.value
+          attr_reader :node
+
+          def initialize(node)
+            @node = node
           end
 
-          def wrap_with_single_quotes(string)
-            "'#{string}'"
+          def message
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
+          end
+
+          def preferred_style
+            "'#{node.value.to_s.tr('_', ' ')}'"
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/single_argument_message_chain.rb b/lib/rubocop/cop/rspec/single_argument_message_chain.rb
index 7c4506d33..66e6afdd6 100644
--- a/lib/rubocop/cop/rspec/single_argument_message_chain.rb
+++ b/lib/rubocop/cop/rspec/single_argument_message_chain.rb
@@ -16,36 +16,42 @@ module RSpec
       #   allow(foo).to receive(:bar, :baz)
       #   allow(foo).to receive("bar.baz")
       #
-      class SingleArgumentMessageChain < Cop
-        MSG = 'Use `%<recommended>s` instead of calling '\
+      class SingleArgumentMessageChain < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<recommended>s` instead of calling ' \
               '`%<called>s` with a single argument.'
+        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
 
-        def_node_matcher :message_chain, <<-PATTERN
+        # @!method message_chain(node)
+        def_node_matcher :message_chain, <<~PATTERN
           (send _ {:receive_message_chain :stub_chain} $_)
         PATTERN
 
+        # @!method single_key_hash?(node)
         def_node_matcher :single_key_hash?, '(hash pair)'
 
         def on_send(node)
           message_chain(node) do |arg|
             return if valid_usage?(arg)
 
-            add_offense(node, location: :selector)
-          end
-        end
+            method = node.method_name
+            msg = format(MSG, recommended: replacement(method), called: method)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement(node.method_name))
-            message_chain(node) do |arg|
-              autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
-              autocorrect_array_arg(corrector, arg) if arg.array_type?
+            add_offense(node.loc.selector, message: msg) do |corrector|
+              autocorrect(corrector, node, method, arg)
             end
           end
         end
 
         private
 
+        def autocorrect(corrector, node, method, arg)
+          corrector.replace(node.loc.selector, replacement(method))
+          autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
+          autocorrect_array_arg(corrector, arg) if arg.array_type?
+        end
+
         def valid_usage?(node)
           return true unless node.literal? || node.array_type?
 
@@ -61,33 +67,25 @@ def single_element_array?(node)
         end
 
         def autocorrect_hash_arg(corrector, arg)
-          key, value = *arg.children.first
-
-          corrector.replace(arg.loc.expression, key_to_arg(key))
+          pair = arg.pairs.first
+          corrector.replace(arg, key_to_arg(pair.key))
           corrector.insert_after(arg.parent.loc.end,
-                                 ".and_return(#{value.source})")
+                                 ".and_return(#{pair.value.source})")
         end
 
         def autocorrect_array_arg(corrector, arg)
           value = arg.children.first
 
-          corrector.replace(arg.loc.expression, value.source)
+          corrector.replace(arg, value.source)
         end
 
         def key_to_arg(node)
-          key, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          node.sym_type? ? ":#{key}" : node.source
+          node.sym_type? ? ":#{node.value}" : node.source
         end
 
         def replacement(method)
           method.equal?(:receive_message_chain) ? 'receive' : 'stub'
         end
-
-        def message(node)
-          method = node.method_name
-
-          format(MSG, recommended: replacement(method), called: method)
-        end
       end
     end
   end
diff --git a/lib/rubocop/cop/rspec/skip_block_inside_example.rb b/lib/rubocop/cop/rspec/skip_block_inside_example.rb
new file mode 100644
index 000000000..7137fd10a
--- /dev/null
+++ b/lib/rubocop/cop/rspec/skip_block_inside_example.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for passing a block to `skip` within examples.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     skip 'not yet implemented' do
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     skip 'not yet implemented'
+      #     do_something
+      #   end
+      #
+      #   # good - when outside example
+      #   skip 'not yet implemented' do
+      #   end
+      #
+      class SkipBlockInsideExample < Base
+        MSG = "Don't pass a block to `skip` inside examples."
+
+        def on_block(node)
+          return unless node.method?(:skip)
+          return unless inside_example?(node)
+
+          add_offense(node)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def inside_example?(node)
+          node.each_ancestor(:block).any? { |ancestor| example?(ancestor) }
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/sort_metadata.rb b/lib/rubocop/cop/rspec/sort_metadata.rb
new file mode 100644
index 000000000..2e9411a44
--- /dev/null
+++ b/lib/rubocop/cop/rspec/sort_metadata.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Sort RSpec metadata alphabetically.
+      #
+      # Only the trailing metadata is sorted.
+      #
+      # @example
+      #   # bad
+      #   describe 'Something', :b, :a
+      #   context 'Something', foo: 'bar', baz: true
+      #   it 'works', :b, :a, foo: 'bar', baz: true
+      #
+      #   # good
+      #   describe 'Something', :a, :b
+      #   context 'Something', baz: true, foo: 'bar'
+      #   it 'works', :a, :b, baz: true, foo: 'bar'
+      #
+      #   # good, trailing metadata is sorted
+      #   describe 'Something', 'description', :a, :b, :z
+      #   context 'Something', :z, variable, :a, :b
+      class SortMetadata < Base
+        extend AutoCorrector
+        include Metadata
+        include RangeHelp
+
+        MSG = 'Sort metadata alphabetically.'
+
+        # @!method match_ambiguous_trailing_metadata?(node)
+        def_node_matcher :match_ambiguous_trailing_metadata?, <<~PATTERN
+          (send _ _ _ ... !{hash sym str dstr xstr})
+        PATTERN
+
+        def on_metadata(args, hash)
+          pairs = hash&.pairs || []
+          symbols = trailing_symbols(args)
+          return if sorted?(symbols, pairs)
+
+          crime_scene = crime_scene(symbols, pairs)
+          add_offense(crime_scene) do |corrector|
+            corrector.replace(crime_scene, replacement(symbols, pairs))
+          end
+        end
+
+        private
+
+        def trailing_symbols(args)
+          args = args[...-1] if last_arg_could_be_a_hash?(args)
+          args.reverse.take_while(&:sym_type?).reverse
+        end
+
+        def last_arg_could_be_a_hash?(args)
+          args.last && match_ambiguous_trailing_metadata?(args.last.parent)
+        end
+
+        def crime_scene(symbols, pairs)
+          metadata = symbols + pairs
+
+          range_between(
+            metadata.first.source_range.begin_pos,
+            metadata.last.source_range.end_pos
+          )
+        end
+
+        def replacement(symbols, pairs)
+          (sort_symbols(symbols) + sort_pairs(pairs)).map(&:source).join(', ')
+        end
+
+        def sorted?(symbols, pairs)
+          symbols == sort_symbols(symbols) && pairs == sort_pairs(pairs)
+        end
+
+        def sort_pairs(pairs)
+          pairs.sort_by { |pair| pair.key.source.downcase }
+        end
+
+        def sort_symbols(symbols)
+          symbols.sort_by { |symbol| symbol.value.to_s.downcase }
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/spec_file_path_format.rb b/lib/rubocop/cop/rspec/spec_file_path_format.rb
new file mode 100644
index 000000000..21466c064
--- /dev/null
+++ b/lib/rubocop/cop/rspec/spec_file_path_format.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that spec file paths are consistent and well-formed.
+      #
+      # @example
+      #   # bad
+      #   whatever_spec.rb         # describe MyClass
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      #   # good
+      #   my_class_spec.rb         # describe MyClass
+      #   my_class_method_spec.rb  # describe MyClass, '#method'
+      #   my_class/method_spec.rb  # describe MyClass, '#method'
+      #
+      # @example `CustomTransform: {RuboCop=>rubocop, RSpec=>rspec}` (default)
+      #   # good
+      #   rubocop_spec.rb          # describe RuboCop
+      #   rspec_spec.rb            # describe RSpec
+      #
+      # @example `IgnoreMethods: false` (default)
+      #   # bad
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      # @example `IgnoreMethods: true`
+      #   # good
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      # @example `IgnoreMetadata: {type=>routing}` (default)
+      #   # good
+      #   whatever_spec.rb         # describe MyClass, type: :routing do; end
+      #
+      class SpecFilePathFormat < Base
+        include TopLevelGroup
+        include Namespace
+        include FileHelp
+
+        MSG = 'Spec path should end with `%<suffix>s`.'
+
+        # @!method example_group_arguments(node)
+        def_node_matcher :example_group_arguments, <<~PATTERN
+          (block $(send #rspec? #ExampleGroups.all $_ $...) ...)
+        PATTERN
+
+        # @!method metadata_key_value(node)
+        def_node_search :metadata_key_value, '(pair (sym $_key) (sym $_value))'
+
+        def on_top_level_example_group(node)
+          return unless top_level_groups.one?
+
+          example_group_arguments(node) do |send_node, class_name, arguments|
+            next if !class_name.const_type? || ignore_metadata?(arguments)
+
+            ensure_correct_file_path(send_node, class_name, arguments)
+          end
+        end
+
+        private
+
+        def ensure_correct_file_path(send_node, class_name, arguments)
+          pattern = correct_path_pattern(class_name, arguments)
+          return if filename_ends_with?(pattern)
+
+          # For the suffix shown in the offense message, modify the regular
+          # expression pattern to resemble a glob pattern for clearer error
+          # messages.
+          suffix = pattern.sub('.*', '*').sub('[^/]*', '*').sub('\.', '.')
+          add_offense(send_node, message: format(MSG, suffix: suffix))
+        end
+
+        def ignore_metadata?(arguments)
+          arguments.any? do |argument|
+            metadata_key_value(argument).any? do |key, value|
+              ignore_metadata.values_at(key.to_s).include?(value.to_s)
+            end
+          end
+        end
+
+        def correct_path_pattern(class_name, arguments)
+          path = [expected_path(class_name)]
+          path << '.*' unless ignore?(arguments.first)
+          path << [name_pattern(arguments.first), '[^/]*_spec\.rb']
+          path.join
+        end
+
+        def name_pattern(method_name)
+          return if ignore?(method_name)
+
+          method_name.str_content.gsub(/\s/, '_').gsub(/\W/, '')
+        end
+
+        def ignore?(method_name)
+          !method_name&.str_type? || ignore_methods?
+        end
+
+        def expected_path(constant)
+          constants = namespace(constant) + constant.const_name.split('::')
+
+          File.join(
+            constants.map do |name|
+              custom_transform.fetch(name) { camel_to_snake_case(name) }
+            end
+          )
+        end
+
+        def camel_to_snake_case(string)
+          string
+            .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
+            .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
+            .downcase
+        end
+
+        def custom_transform
+          cop_config.fetch('CustomTransform', {})
+        end
+
+        def ignore_methods?
+          cop_config['IgnoreMethods']
+        end
+
+        def ignore_metadata
+          cop_config.fetch('IgnoreMetadata', {})
+        end
+
+        def filename_ends_with?(pattern)
+          expanded_file_path.match?("#{pattern}$")
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/spec_file_path_suffix.rb b/lib/rubocop/cop/rspec/spec_file_path_suffix.rb
new file mode 100644
index 000000000..d013c47a8
--- /dev/null
+++ b/lib/rubocop/cop/rspec/spec_file_path_suffix.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that spec file paths suffix are consistent and well-formed.
+      #
+      # @example
+      #   # bad
+      #   my_class/foo_specorb.rb   # describe MyClass
+      #   spec/models/user.rb       # describe User
+      #   spec/models/user_specxrb  # describe User
+      #
+      #   # good
+      #   my_class_spec.rb          # describe MyClass
+      #
+      #   # good - shared examples are allowed
+      #   spec/models/user.rb       # shared_examples_for 'foo'
+      #
+      class SpecFilePathSuffix < Base
+        include TopLevelGroup
+        include FileHelp
+
+        MSG = 'Spec path should end with `_spec.rb`.'
+
+        def on_top_level_example_group(node)
+          example_group?(node) do
+            add_global_offense(MSG) unless correct_path?
+          end
+        end
+
+        private
+
+        def correct_path?
+          expanded_file_path.end_with?('_spec.rb')
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/stubbed_mock.rb b/lib/rubocop/cop/rspec/stubbed_mock.rb
new file mode 100644
index 000000000..1787246c5
--- /dev/null
+++ b/lib/rubocop/cop/rspec/stubbed_mock.rb
@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that message expectations do not have a configured response.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to receive(:bar).with(42).and_return("hello world")
+      #
+      #   # good (without spies)
+      #   allow(foo).to receive(:bar).with(42).and_return("hello world")
+      #   expect(foo).to receive(:bar).with(42)
+      #
+      class StubbedMock < Base
+        MSG = 'Prefer %<replacement>s over `%<method_name>s` when ' \
+              'configuring a response.'
+        RESTRICT_ON_SEND = %i[to].freeze
+
+        # @!method message_expectation?(node)
+        #   Match message expectation matcher
+        #
+        #   @example source that matches
+        #     receive(:foo)
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, :bar)
+        #
+        #   @example source that matches
+        #     receive(:foo).with('bar')
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :message_expectation?, <<~PATTERN
+          {
+            (send nil? { :receive :receive_message_chain } ...)  # receive(:foo)
+            (send (send nil? :receive ...) :with ...)            # receive(:foo).with('bar')
+          }
+        PATTERN
+
+        # @!method configured_response?(node)
+        def_node_matcher :configured_response?, <<~PATTERN
+          { :and_return :and_raise :and_throw :and_yield
+            :and_call_original :and_wrap_original }
+        PATTERN
+
+        # @!method expectation(node)
+        #   Match expectation
+        #
+        #   @example source that matches
+        #     is_expected.to be_in_the_bar
+        #
+        #   @example source that matches
+        #     expect(cocktail).to contain_exactly(:fresh_orange_juice, :campari)
+        #
+        #   @example source that matches
+        #     expect_any_instance_of(Officer).to be_alert
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] expectation, method name, matcher
+        def_node_matcher :expectation, <<~PATTERN
+          (send
+            $(send nil? $#Expectations.all ...)
+            :to $_)
+        PATTERN
+
+        # @!method matcher_with_configured_response(node)
+        #   Match matcher with a configured response
+        #
+        #   @example source that matches
+        #     receive(:foo).and_return('bar')
+        #
+        #   @example source that matches
+        #     receive(:lower).and_raise(SomeError)
+        #
+        #   @example source that matches
+        #     receive(:redirect).and_call_original
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_configured_response, <<~PATTERN
+          (send #message_expectation? #configured_response? _)
+        PATTERN
+
+        # @!method matcher_with_return_block(node)
+        #   Match matcher with a return block
+        #
+        #   @example source that matches
+        #     receive(:foo) { 'bar' }
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_return_block, <<~PATTERN
+          (block #message_expectation? (args) _)  # receive(:foo) { 'bar' }
+        PATTERN
+
+        # @!method matcher_with_hash(node)
+        #   Match matcher with a configured response defined as a hash
+        #
+        #   @example source that matches
+        #     receive_messages(foo: 'bar', baz: 'qux')
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, bar: 'baz')
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_hash, <<~PATTERN
+          {
+            (send nil? :receive_messages hash)           # receive_messages(foo: 'bar', baz: 'qux')
+            (send nil? :receive_message_chain ... hash)  # receive_message_chain(:foo, bar: 'baz')
+          }
+        PATTERN
+
+        # @!method matcher_with_blockpass(node)
+        #   Match matcher with a configured response in block-pass
+        #
+        #   @example source that matches
+        #     receive(:foo, &canned)
+        #
+        #   @example source that matches
+        #     receive_message_chain(:foo, :bar, &canned)
+        #
+        #   @example source that matches
+        #     receive(:foo).with('bar', &canned)
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @yield [RuboCop::AST::Node] matcher
+        def_node_matcher :matcher_with_blockpass, <<~PATTERN
+          {
+            (send nil? { :receive :receive_message_chain } ... block_pass)  # receive(:foo, &canned)
+            (send (send nil? :receive ...) :with ... block_pass)            # receive(:foo).with('foo', &canned)
+          }
+        PATTERN
+
+        def on_send(node)
+          expectation(node) do |expectation, method_name, matcher|
+            on_expectation(expectation, method_name, matcher)
+          end
+        end
+
+        private
+
+        def on_expectation(expectation, method_name, matcher)
+          flag_expectation = lambda do
+            add_offense(expectation, message: msg(method_name))
+          end
+
+          matcher_with_configured_response(matcher, &flag_expectation)
+          matcher_with_return_block(matcher, &flag_expectation)
+          matcher_with_hash(matcher, &flag_expectation)
+          matcher_with_blockpass(matcher, &flag_expectation)
+        end
+
+        def msg(method_name)
+          format(
+            MSG,
+            method_name: method_name,
+            replacement: replacement(method_name)
+          )
+        end
+
+        def replacement(method_name)
+          case method_name
+          when :expect
+            '`allow`'
+          when :is_expected
+            '`allow(subject)`'
+          when :expect_any_instance_of
+            '`allow_any_instance_of`'
+          else
+            'an allow statement'
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/subject_declaration.rb b/lib/rubocop/cop/rspec/subject_declaration.rb
new file mode 100644
index 000000000..e3d588b42
--- /dev/null
+++ b/lib/rubocop/cop/rspec/subject_declaration.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensure that subject is defined using subject helper.
+      #
+      # @example
+      #   # bad
+      #   let(:subject) { foo }
+      #   let!(:subject) { foo }
+      #   subject(:subject) { foo }
+      #   subject!(:subject) { foo }
+      #
+      #   # bad
+      #   block = -> {}
+      #   let(:subject, &block)
+      #
+      #   # good
+      #   subject(:test_subject) { foo }
+      #
+      class SubjectDeclaration < Base
+        MSG_LET = 'Use subject explicitly rather than using let'
+        MSG_REDUNDANT = 'Ambiguous declaration of subject'
+
+        # @!method offensive_subject_declaration?(node)
+        def_node_matcher :offensive_subject_declaration?, <<~PATTERN
+          (send nil? ${#Subjects.all #Helpers.all} ({sym str} #Subjects.all) ...)
+        PATTERN
+
+        def on_send(node)
+          offense = offensive_subject_declaration?(node)
+          return unless offense
+
+          add_offense(node, message: message_for(offense))
+        end
+
+        private
+
+        def message_for(offense)
+          Helpers.all(offense) ? MSG_LET : MSG_REDUNDANT
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/subject_stub.rb b/lib/rubocop/cop/rspec/subject_stub.rb
index 7454a32a6..273e4fea9 100644
--- a/lib/rubocop/cop/rspec/subject_stub.rb
+++ b/lib/rubocop/cop/rspec/subject_stub.rb
@@ -1,48 +1,86 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     module RSpec
       # Checks for stubbed test subjects.
       #
+      # Checks nested subject stubs for innermost subject definition
+      # when subject is also defined in parent example groups.
+      #
       # @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
-      # @see https://samphippen.com/introducing-rspec-smells-and-where-to-find-them#smell-1-stubject
-      # @see https://github.com/rubocop-hq/rspec-style-guide#dont-stub-subject
+      # @see https://penelope.zone/2015/12/27/introducing-rspec-smells-and-where-to-find-them.html#smell-1-stubjec
       #
       # @example
       #   # bad
-      #   describe Foo do
-      #     subject(:bar) { baz }
+      #   describe Article do
+      #     subject(:article) { Article.new }
+      #
+      #     it 'indicates that the author is unknown' do
+      #       allow(article).to receive(:author).and_return(nil)
+      #       expect(article.description).to include('by an unknown author')
+      #     end
+      #   end
+      #
+      #   # bad
+      #   describe Article do
+      #     subject(:foo) { Article.new }
+      #
+      #     context 'nested subject' do
+      #       subject(:article) { Article.new }
       #
-      #     before do
-      #       allow(bar).to receive(:qux?).and_return(true)
+      #       it 'indicates that the author is unknown' do
+      #         allow(article).to receive(:author).and_return(nil)
+      #         expect(article.description).to include('by an unknown author')
+      #       end
       #     end
       #   end
       #
-      class SubjectStub < Cop
+      #   # good
+      #   describe Article do
+      #     subject(:article) { Article.new(author: nil) }
+      #
+      #     it 'indicates that the author is unknown' do
+      #       expect(article.description).to include('by an unknown author')
+      #     end
+      #   end
+      #
+      class SubjectStub < Base
+        include TopLevelGroup
+
         MSG = 'Do not stub methods of the object under test.'
 
-        # @!method subject(node)
+        # @!method subject?(node)
         #   Find a named or unnamed subject definition
         #
         #   @example anonymous subject
-        #     subject(parse('subject { foo }').ast) do |name|
+        #     subject?(parse('subject { foo }').ast) do |name|
         #       name # => :subject
         #     end
         #
         #   @example named subject
-        #     subject(parse('subject(:thing) { foo }').ast) do |name|
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
         #       name # => :thing
         #     end
         #
-        #   @param node [RuboCop::Node]
+        #   @param node [RuboCop::AST::Node]
         #
         #   @yield [Symbol] subject name
-        def_node_matcher :subject, <<-PATTERN
-          {
-            (block (send nil? :subject (sym $_)) args ...)
-            (block (send nil? $:subject) args ...)
-          }
+        def_node_matcher :subject?, <<~PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method let?(node)
+        #   Find a memoized helper
+        def_node_matcher :let?, <<~PATTERN
+          (block
+            (send nil? :let (sym $_)
+            ) args ...)
         PATTERN
 
         # @!method message_expectation?(node, method_name)
@@ -56,89 +94,59 @@ class SubjectStub < Cop
         #     expect(foo).to receive(:bar).with(1)
         #     expect(foo).to receive(:bar).with(1).and_return(2)
         #
-        def_node_matcher :message_expectation?, <<-PATTERN
+        def_node_matcher :message_expectation?, <<~PATTERN
           (send
             {
-              (send nil? { :expect :allow } (send nil? {% :subject}))
+              (send nil? { :expect :allow } (send nil? %))
               (send nil? :is_expected)
             }
-            #{Runners::ALL.node_pattern_union}
+            #Runners.all
             #message_expectation_matcher?
           )
         PATTERN
 
-        def_node_search :message_expectation_matcher?, <<-PATTERN
+        # @!method message_expectation_matcher?(node)
+        def_node_search :message_expectation_matcher?, <<~PATTERN
           (send nil? {
             :receive :receive_messages :receive_message_chain :have_received
             } ...)
         PATTERN
 
-        def on_block(node)
-          return unless example_group?(node)
+        def on_top_level_group(node)
+          @explicit_subjects = find_all_explicit(node) { |n| subject?(n) }
+          @subject_overrides = find_all_explicit(node) { |n| let?(n) }
 
-          find_subject_stub(node) do |stub|
+          find_subject_expectations(node) do |stub|
             add_offense(stub)
           end
         end
 
         private
 
-        # Find subjects within tree and then find (send) nodes for that subject
-        #
-        # @param node [RuboCop::Node] example group
-        #
-        # @yield [RuboCop::Node] message expectations for subject
-        def find_subject_stub(node, &block)
-          find_subject(node) do |subject_name, context|
-            find_subject_expectation(context, subject_name, &block)
-          end
-        end
-
-        # Find a subject message expectation
-        #
-        # @param node [RuboCop::Node]
-        # @param subject_name [Symbol] name of subject
-        #
-        # @yield [RuboCop::Node] message expectation
-        def find_subject_expectation(node, subject_name, &block)
-          # Do not search node if it is an example group with its own subject.
-          return if example_group?(node) && redefines_subject?(node)
+        def find_all_explicit(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            name = yield(child)
+            next unless name
 
-          # Yield the current node if it is a message expectation.
-          yield(node) if message_expectation?(node, subject_name)
+            outer_example_group = child.each_ancestor(:block).find do |a|
+              example_group?(a)
+            end
 
-          # Recurse through node's children looking for a message expectation.
-          node.each_child_node do |child|
-            find_subject_expectation(child, subject_name, &block)
+            h[outer_example_group] ||= []
+            h[outer_example_group] << name
           end
         end
 
-        # Check if node's children contain a subject definition
-        #
-        # @param node [RuboCop::Node]
-        #
-        # @return [Boolean]
-        def redefines_subject?(node)
-          node.each_child_node.any? do |child|
-            subject(child) || redefines_subject?(child)
-          end
-        end
-
-        # Find a subject definition
-        #
-        # @param node [RuboCop::Node]
-        # @param parent [RuboCop::Node,nil]
-        #
-        # @yieldparam subject_name [Symbol] name of subject being defined
-        # @yieldparam parent [RuboCop::Node] parent of subject definition
-        def find_subject(node, parent: nil, &block)
-          # An implicit subject is defined by RSpec when no subject is declared
-          subject_name = subject(node) || :subject
+        def find_subject_expectations(node, subject_names = [], &block)
+          subject_names = [*subject_names, *@explicit_subjects[node]]
+          subject_names -= @subject_overrides[node] if @subject_overrides[node]
 
-          yield(subject_name, parent) if parent
+          names = Set[*subject_names, :subject]
+          expectation_detected = message_expectation?(node, names)
+          return yield(node) if expectation_detected
 
-          node.each_child_node do |child|
-            find_subject(child, parent: node, &block)
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            find_subject_expectations(child, subject_names, &block)
           end
         end
       end
diff --git a/lib/rubocop/cop/rspec/undescriptive_literals_description.rb b/lib/rubocop/cop/rspec/undescriptive_literals_description.rb
new file mode 100644
index 000000000..73cd90662
--- /dev/null
+++ b/lib/rubocop/cop/rspec/undescriptive_literals_description.rb
@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Description should be descriptive.
+      #
+      # If example group or example contains only `execute string`, numbers
+      # and regular expressions, the description is not clear.
+      #
+      # @example
+      #   # bad
+      #   describe `time` do
+      #    # ...
+      #   end
+      #
+      #   # bad
+      #   context /when foo/ do
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   it 10000 do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe Foo do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   describe '#foo' do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   context "when #{foo} is bar" do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   it 'does something' do
+      #     # ...
+      #   end
+      #
+      class UndescriptiveLiteralsDescription < Base
+        MSG = 'Description should be descriptive.'
+
+        # @!method example_groups_or_example?(node)
+        def_node_matcher :example_groups_or_example?, <<~PATTERN
+          (block (send #rspec? {#ExampleGroups.all #Examples.all} $_) ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          example_groups_or_example?(node) do |arg|
+            add_offense(arg) if offense?(arg)
+          end
+        end
+
+        private
+
+        def offense?(node)
+          %i[xstr int regexp].include?(node.type)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/unspecified_exception.rb b/lib/rubocop/cop/rspec/unspecified_exception.rb
index 893264f8a..e7d90fec1 100644
--- a/lib/rubocop/cop/rspec/unspecified_exception.rb
+++ b/lib/rubocop/cop/rspec/unspecified_exception.rb
@@ -10,52 +10,63 @@ module RSpec
       # to `raise_error`
       #
       # @example
+      #   # bad
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error
       #
-      #     # bad
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error
+      #   # good
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error(StandardError)
       #
-      #     # good
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error(StandardError)
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error('error')
       #
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error('error')
+      #   expect {
+      #     raise StandardError.new('error')
+      #   }.to raise_error(/err/)
       #
-      #     expect {
-      #       raise StandardError.new('error')
-      #     }.to raise_error(/err/)
+      #   expect { do_something }.not_to raise_error
       #
-      #     expect { do_something }.not_to raise_error
-      class UnspecifiedException < Cop
+      class UnspecifiedException < Base
         MSG = 'Specify the exception being captured'
 
-        def_node_matcher :empty_raise_error_or_exception, <<-PATTERN
-          (send
-            (block
-                (send nil? :expect) ...)
-            :to
-            (send nil? {:raise_error :raise_exception})
-          )
+        RESTRICT_ON_SEND = %i[
+          raise_exception
+          raise_error
+        ].freeze
+
+        # @!method expect_to?(node)
+        def_node_matcher :expect_to?, <<~PATTERN
+          (send (block (send nil? :expect) ...) :to ...)
         PATTERN
 
         def on_send(node)
           return unless empty_exception_matcher?(node)
 
-          add_offense(node.children.last)
+          add_offense(node)
         end
 
+        private
+
         def empty_exception_matcher?(node)
-          empty_raise_error_or_exception(node) && !block_with_args?(node.parent)
+          return false if node.arguments? || node.block_literal?
+
+          expect_to = find_expect_to(node)
+          return false unless expect_to
+          return false if expect_to.block_node&.arguments?
+
+          true
         end
 
-        def block_with_args?(node)
-          return unless node&.block_type?
+        def find_expect_to(node)
+          node.each_ancestor.find do |ancestor|
+            break if ancestor.block_type?
 
-          node.arguments?
+            expect_to?(ancestor)
+          end
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/variable_definition.rb b/lib/rubocop/cop/rspec/variable_definition.rb
new file mode 100644
index 000000000..b438e8609
--- /dev/null
+++ b/lib/rubocop/cop/rspec/variable_definition.rb
@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that memoized helpers names are symbols or strings.
+      #
+      # @example EnforcedStyle: symbols (default)
+      #   # bad
+      #   subject('user') { create_user }
+      #   let('user_name') { 'Adam' }
+      #
+      #   # good
+      #   subject(:user) { create_user }
+      #   let(:user_name) { 'Adam' }
+      #
+      # @example EnforcedStyle: strings
+      #   # bad
+      #   subject(:user) { create_user }
+      #   let(:user_name) { 'Adam' }
+      #
+      #   # good
+      #   subject('user') { create_user }
+      #   let('user_name') { 'Adam' }
+      #
+      class VariableDefinition < Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include Variable
+        include InsideExampleGroup
+
+        MSG = 'Use %<style>s for variable names.'
+
+        def on_send(node)
+          return unless inside_example_group?(node)
+
+          variable_definition?(node) do |variable|
+            next unless style_offense?(variable)
+
+            add_offense(
+              variable,
+              message: format(MSG, style: style)
+            ) do |corrector|
+              corrector.replace(variable, correct_variable(variable))
+            end
+          end
+        end
+
+        private
+
+        def correct_variable(variable)
+          case variable.type
+          when :dsym
+            variable.source[1..]
+          when :sym
+            variable.value.to_s.inspect
+          else
+            variable.value.to_sym.inspect
+          end
+        end
+
+        def style_offense?(variable)
+          (style == :symbols && string?(variable)) ||
+            (style == :strings && symbol?(variable))
+        end
+
+        def string?(node)
+          node.str_type?
+        end
+
+        def symbol?(node)
+          node.type?(:sym, :dsym)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/variable_name.rb b/lib/rubocop/cop/rspec/variable_name.rb
new file mode 100644
index 000000000..333400f12
--- /dev/null
+++ b/lib/rubocop/cop/rspec/variable_name.rb
@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that memoized helper names use the configured style.
+      #
+      # Variables can be excluded from checking using the `AllowedPatterns`
+      # option.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   subject(:userName1) { 'Adam' }
+      #   let(:userName2) { 'Adam' }
+      #
+      #   # good
+      #   subject(:user_name_1) { 'Adam' }
+      #   let(:user_name_2) { 'Adam' }
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   subject(:user_name_1) { 'Adam' }
+      #   let(:user_name_2) { 'Adam' }
+      #
+      #   # good
+      #   subject(:userName1) { 'Adam' }
+      #   let(:userName2) { 'Adam' }
+      #
+      # @example AllowedPatterns configuration
+      #   # rubocop.yml
+      #   # RSpec/VariableName:
+      #   #   EnforcedStyle: snake_case
+      #   #   AllowedPatterns:
+      #   #     - ^userFood
+      #
+      # @example
+      #   # okay because it matches the `^userFood` regex in `AllowedPatterns`
+      #   subject(:userFood_1) { 'spaghetti' }
+      #   let(:userFood_2) { 'fettuccine' }
+      #
+      class VariableName < Base
+        include ConfigurableNaming
+        include AllowedPattern
+        include Variable
+        include InsideExampleGroup
+
+        MSG = 'Use %<style>s for variable names.'
+
+        def on_send(node)
+          return unless inside_example_group?(node)
+
+          variable_definition?(node) do |variable|
+            return if variable.type?(:dstr, :dsym)
+            return if matches_allowed_pattern?(variable.value)
+
+            check_name(node, variable.value, variable.source_range)
+          end
+        end
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/verified_double_reference.rb b/lib/rubocop/cop/rspec/verified_double_reference.rb
new file mode 100644
index 000000000..1a3621a26
--- /dev/null
+++ b/lib/rubocop/cop/rspec/verified_double_reference.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for consistent verified double reference style.
+      #
+      # @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
+      #
+      # @safety
+      #   This cop is unsafe because the correction requires loading the class.
+      #   Loading before stubbing causes RSpec to only allow instance methods
+      #   to be stubbed.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) do
+      #     instance_double('ClassName', method_name: 'returned_value')
+      #   end
+      #
+      #   # good
+      #   let(:foo) do
+      #     instance_double(ClassName, method_name: 'returned_value')
+      #   end
+      #
+      # @example Reference is any dynamic variable. No enforcement
+      #
+      #   # good
+      #   let(:foo) do
+      #     instance_double(@klass, method_name: 'returned_value')
+      #   end
+      class VerifiedDoubleReference < Base
+        extend AutoCorrector
+
+        MSG = 'Use a constant class reference for verified doubles. ' \
+              'String references are not verifying unless the class is loaded.'
+
+        RESTRICT_ON_SEND = Set[
+          :class_double,
+          :class_spy,
+          :instance_double,
+          :instance_spy,
+          :mock_model,
+          :object_double,
+          :object_spy,
+          :stub_model
+        ].freeze
+
+        # @!method verified_double(node)
+        def_node_matcher :verified_double, <<~PATTERN
+          (send
+            nil?
+            RESTRICT_ON_SEND
+            $str
+            ...)
+        PATTERN
+
+        def on_send(node)
+          verified_double(node) do |string_argument_node|
+            add_offense(string_argument_node) do |corrector|
+              autocorrect(corrector, string_argument_node)
+            end
+          end
+        end
+
+        def autocorrect(corrector, node)
+          corrector.replace(node, node.value)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/cop/rspec/verified_doubles.rb b/lib/rubocop/cop/rspec/verified_doubles.rb
index 7906cc221..51c6137c0 100644
--- a/lib/rubocop/cop/rspec/verified_doubles.rb
+++ b/lib/rubocop/cop/rspec/verified_doubles.rb
@@ -5,7 +5,7 @@ module Cop
     module RSpec
       # Prefer using verifying doubles over normal doubles.
       #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles
+      # @see https://rspec.info/features/3-12/rspec-mocks/verifying-doubles
       #
       # @example
       #   # bad
@@ -22,10 +22,13 @@ module RSpec
       #   let(:foo) do
       #     instance_double("ClassName", method_name: 'returned value')
       #   end
-      class VerifiedDoubles < Cop
+      #
+      class VerifiedDoubles < Base
         MSG = 'Prefer using verifying doubles over normal doubles.'
+        RESTRICT_ON_SEND = %i[double spy].freeze
 
-        def_node_matcher :unverified_double, <<-PATTERN
+        # @!method unverified_double(node)
+        def_node_matcher :unverified_double, <<~PATTERN
           {(send nil? {:double :spy} $...)}
         PATTERN
 
diff --git a/lib/rubocop/cop/rspec/void_expect.rb b/lib/rubocop/cop/rspec/void_expect.rb
index 11c5f49cb..52f32147c 100644
--- a/lib/rubocop/cop/rspec/void_expect.rb
+++ b/lib/rubocop/cop/rspec/void_expect.rb
@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # This cop checks void `expect()`.
+      # Checks void `expect()`.
       #
       # @example
       #   # bad
@@ -11,26 +11,32 @@ module RSpec
       #
       #   # good
       #   expect(something).to be(1)
-      class VoidExpect < Cop
+      #
+      class VoidExpect < Base
         MSG = 'Do not use `expect()` without `.to` or `.not_to`. ' \
               'Chain the methods or remove it.'
+        RESTRICT_ON_SEND = %i[expect].freeze
 
-        def_node_matcher :expect?, <<-PATTERN
+        # @!method expect?(node)
+        def_node_matcher :expect?, <<~PATTERN
           (send nil? :expect ...)
         PATTERN
 
-        def_node_matcher :expect_block?, <<-PATTERN
+        # @!method expect_block?(node)
+        def_node_matcher :expect_block?, <<~PATTERN
           (block #expect? (args) _body)
         PATTERN
 
         def on_send(node)
           return unless expect?(node)
+          return unless inside_example?(node)
 
           check_expect(node)
         end
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless expect_block?(node)
+          return unless inside_example?(node)
 
           check_expect(node)
         end
@@ -45,9 +51,13 @@ def check_expect(node)
 
         def void?(expect)
           parent = expect.parent
-          return true unless parent
           return true if parent.begin_type?
-          return true if parent.block_type? && parent.body == expect
+
+          parent.block_type? && parent.body == expect
+        end
+
+        def inside_example?(node)
+          node.each_ancestor(:block).any? { |ancestor| example?(ancestor) }
         end
       end
     end
diff --git a/lib/rubocop/cop/rspec/yield.rb b/lib/rubocop/cop/rspec/yield.rb
index 1d931c978..555929dc0 100644
--- a/lib/rubocop/cop/rspec/yield.rb
+++ b/lib/rubocop/cop/rspec/yield.rb
@@ -3,46 +3,53 @@
 module RuboCop
   module Cop
     module RSpec
-      # This cop checks for calling a block within a stub.
+      # Checks for calling a block within a stub.
       #
       # @example
       #   # bad
       #   allow(foo).to receive(:bar) { |&block| block.call(1) }
       #
       #   # good
-      #   expect(foo).to be(:bar).and_yield(1)
-      class Yield < Cop
+      #   expect(foo).to receive(:bar).and_yield(1)
+      #
+      class Yield < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Use `.and_yield`.'
 
+        # @!method method_on_stub?(node)
         def_node_search :method_on_stub?, '(send nil? :receive ...)'
 
+        # @!method block_arg(node)
         def_node_matcher :block_arg, '(args (blockarg $_))'
 
+        # @!method block_call?(node)
         def_node_matcher :block_call?, '(send (lvar %) :call ...)'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless method_on_stub?(node.send_node)
 
           block_arg(node.arguments) do |block|
             if calling_block?(node.body, block)
-              add_offense(node, location: block_range(node))
-            end
-          end
-        end
+              range = block_range(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            node_range = range_with_surrounding_space(
-              range: block_range(node), side: :left
-            )
-            corrector.replace(node_range, generate_replacement(node.body))
+              add_offense(range) do |corrector|
+                autocorrect(corrector, node, range)
+              end
+            end
           end
         end
 
         private
 
+        def autocorrect(corrector, node, range)
+          corrector.replace(
+            range_with_surrounding_space(range, side: :left),
+            generate_replacement(node.body)
+          )
+        end
+
         def calling_block?(node, block)
           if node.begin_type?
             node.each_child_node.all? { |child| block_call?(child, block) }
diff --git a/lib/rubocop/cop/rspec_cops.rb b/lib/rubocop/cop/rspec_cops.rb
index 5f2a1719b..cf2879e11 100644
--- a/lib/rubocop/cop/rspec_cops.rb
+++ b/lib/rubocop/cop/rspec_cops.rb
@@ -1,25 +1,18 @@
 # frozen_string_literal: true
 
-require_relative 'rspec/capybara/current_path_expectation'
-require_relative 'rspec/capybara/feature_methods'
-
-require_relative 'rspec/factory_bot/attribute_defined_statically'
-require_relative 'rspec/factory_bot/create_list'
-require_relative 'rspec/factory_bot/factory_class_name'
-
-begin
-  require_relative 'rspec/rails/http_status'
-rescue LoadError # rubocop:disable Lint/SuppressedException
-  # Rails/HttpStatus cannot be loaded if rack/utils is unavailable.
-end
-
 require_relative 'rspec/align_left_let_brace'
 require_relative 'rspec/align_right_let_brace'
 require_relative 'rspec/any_instance'
 require_relative 'rspec/around_block'
 require_relative 'rspec/be'
+require_relative 'rspec/be_empty'
+require_relative 'rspec/be_eq'
 require_relative 'rspec/be_eql'
+require_relative 'rspec/be_nil'
 require_relative 'rspec/before_after_all'
+require_relative 'rspec/change_by_zero'
+require_relative 'rspec/class_check'
+require_relative 'rspec/contain_exactly'
 require_relative 'rspec/context_method'
 require_relative 'rspec/context_wording'
 require_relative 'rspec/describe_class'
@@ -28,62 +21,93 @@
 require_relative 'rspec/described_class'
 require_relative 'rspec/described_class_module_wrapping'
 require_relative 'rspec/dialect'
+require_relative 'rspec/duplicated_metadata'
 require_relative 'rspec/empty_example_group'
+require_relative 'rspec/empty_hook'
 require_relative 'rspec/empty_line_after_example'
 require_relative 'rspec/empty_line_after_example_group'
 require_relative 'rspec/empty_line_after_final_let'
 require_relative 'rspec/empty_line_after_hook'
 require_relative 'rspec/empty_line_after_subject'
+require_relative 'rspec/empty_metadata'
+require_relative 'rspec/empty_output'
+require_relative 'rspec/eq'
 require_relative 'rspec/example_length'
 require_relative 'rspec/example_without_description'
 require_relative 'rspec/example_wording'
+require_relative 'rspec/excessive_docstring_spacing'
 require_relative 'rspec/expect_actual'
 require_relative 'rspec/expect_change'
 require_relative 'rspec/expect_in_hook'
+require_relative 'rspec/expect_in_let'
 require_relative 'rspec/expect_output'
-require_relative 'rspec/file_path'
 require_relative 'rspec/focus'
 require_relative 'rspec/hook_argument'
 require_relative 'rspec/hooks_before_examples'
+require_relative 'rspec/identical_equality_assertion'
 require_relative 'rspec/implicit_block_expectation'
 require_relative 'rspec/implicit_expect'
 require_relative 'rspec/implicit_subject'
+require_relative 'rspec/include_examples'
+require_relative 'rspec/indexed_let'
 require_relative 'rspec/instance_spy'
 require_relative 'rspec/instance_variable'
-require_relative 'rspec/invalid_predicate_matcher'
+require_relative 'rspec/is_expected_specify'
 require_relative 'rspec/it_behaves_like'
 require_relative 'rspec/iterated_expectation'
 require_relative 'rspec/leading_subject'
 require_relative 'rspec/leaky_constant_declaration'
 require_relative 'rspec/let_before_examples'
 require_relative 'rspec/let_setup'
+require_relative 'rspec/match_array'
 require_relative 'rspec/message_chain'
 require_relative 'rspec/message_expectation'
 require_relative 'rspec/message_spies'
+require_relative 'rspec/metadata_style'
 require_relative 'rspec/missing_example_group_argument'
+require_relative 'rspec/missing_expectation_target_method'
 require_relative 'rspec/multiple_describes'
 require_relative 'rspec/multiple_expectations'
+require_relative 'rspec/multiple_memoized_helpers'
 require_relative 'rspec/multiple_subjects'
 require_relative 'rspec/named_subject'
 require_relative 'rspec/nested_groups'
+require_relative 'rspec/no_expectation_example'
 require_relative 'rspec/not_to_not'
 require_relative 'rspec/overwriting_setup'
 require_relative 'rspec/pending'
+require_relative 'rspec/pending_without_reason'
 require_relative 'rspec/predicate_matcher'
 require_relative 'rspec/receive_counts'
+require_relative 'rspec/receive_messages'
 require_relative 'rspec/receive_never'
+require_relative 'rspec/redundant_around'
+require_relative 'rspec/redundant_predicate_matcher'
+require_relative 'rspec/remove_const'
 require_relative 'rspec/repeated_description'
 require_relative 'rspec/repeated_example'
 require_relative 'rspec/repeated_example_group_body'
 require_relative 'rspec/repeated_example_group_description'
+require_relative 'rspec/repeated_include_example'
+require_relative 'rspec/repeated_subject_call'
 require_relative 'rspec/return_from_stub'
 require_relative 'rspec/scattered_let'
 require_relative 'rspec/scattered_setup'
 require_relative 'rspec/shared_context'
 require_relative 'rspec/shared_examples'
 require_relative 'rspec/single_argument_message_chain'
+require_relative 'rspec/skip_block_inside_example'
+require_relative 'rspec/sort_metadata'
+require_relative 'rspec/spec_file_path_format'
+require_relative 'rspec/spec_file_path_suffix'
+require_relative 'rspec/stubbed_mock'
+require_relative 'rspec/subject_declaration'
 require_relative 'rspec/subject_stub'
+require_relative 'rspec/undescriptive_literals_description'
 require_relative 'rspec/unspecified_exception'
+require_relative 'rspec/variable_definition'
+require_relative 'rspec/variable_name'
+require_relative 'rspec/verified_double_reference'
 require_relative 'rspec/verified_doubles'
 require_relative 'rspec/void_expect'
 require_relative 'rspec/yield'
diff --git a/lib/rubocop/rspec.rb b/lib/rubocop/rspec.rb
index 7c78f4e43..e53c3ce5a 100644
--- a/lib/rubocop/rspec.rb
+++ b/lib/rubocop/rspec.rb
@@ -3,10 +3,5 @@
 module RuboCop
   # RuboCop RSpec project namespace
   module RSpec
-    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
   end
 end
diff --git a/lib/rubocop/rspec/align_let_brace.rb b/lib/rubocop/rspec/align_let_brace.rb
index 83c684bfe..d5c01fdc0 100644
--- a/lib/rubocop/rspec/align_let_brace.rb
+++ b/lib/rubocop/rspec/align_let_brace.rb
@@ -4,7 +4,8 @@ module RuboCop
   module RSpec
     # Shared behavior for aligning braces for single line lets
     class AlignLetBrace
-      include RuboCop::RSpec::Language::NodePattern
+      include RuboCop::RSpec::Language
+      include RuboCop::Cop::Util
 
       def initialize(root, token)
         @root  = root
@@ -34,7 +35,7 @@ def target_column_for(let)
       def let_group_for(let)
         adjacent_let_chunks.detect do |chunk|
           chunk.any? do |member|
-            member == let && member.loc.line == let.loc.line
+            member == let && same_line?(member, let)
           end
         end
       end
diff --git a/lib/rubocop/rspec/blank_line_separation.rb b/lib/rubocop/rspec/blank_line_separation.rb
deleted file mode 100644
index 6b9ce28aa..000000000
--- a/lib/rubocop/rspec/blank_line_separation.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Helps determine the offending location if there is not a blank line
-    # following the node. Allows comments to follow directly after.
-    module BlankLineSeparation
-      include FinalEndLocation
-      include RuboCop::Cop::RangeHelp
-
-      def missing_separating_line(node)
-        line = final_end_location(node).line
-
-        line += 1 while comment_line?(processed_source[line])
-
-        return if processed_source[line].blank?
-
-        yield offending_loc(line)
-      end
-
-      def offending_loc(last_line)
-        offending_line = processed_source[last_line - 1]
-
-        content_length = offending_line.lstrip.length
-        start          = offending_line.length - content_length
-
-        source_range(processed_source.buffer, last_line, start, content_length)
-      end
-
-      def last_child?(node)
-        return true unless node.parent&.begin_type?
-
-        node.equal?(node.parent.children.last)
-      end
-
-      def autocorrect(node)
-        lambda do |corrector|
-          missing_separating_line(node) do |location|
-            corrector.insert_after(location.end, "\n")
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/concept.rb b/lib/rubocop/rspec/concept.rb
index 9a66ede9d..037c8835f 100644
--- a/lib/rubocop/rspec/concept.rb
+++ b/lib/rubocop/rspec/concept.rb
@@ -4,9 +4,8 @@ module RuboCop
   module RSpec
     # Wrapper for RSpec DSL methods
     class Concept
+      extend RuboCop::NodePattern::Macros
       include Language
-      include Language::NodePattern
-      extend NodePattern::Macros
 
       def initialize(node)
         @node = node
diff --git a/lib/rubocop/rspec/config_formatter.rb b/lib/rubocop/rspec/config_formatter.rb
index 15be1b860..88c441229 100644
--- a/lib/rubocop/rspec/config_formatter.rb
+++ b/lib/rubocop/rspec/config_formatter.rb
@@ -6,8 +6,8 @@ module RuboCop
   module RSpec
     # Builds a YAML config file from two config hashes
     class ConfigFormatter
-      NAMESPACES = /^(RSpec|Capybara|FactoryBot|Rails)/.freeze
-      STYLE_GUIDE_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/'
+      EXTENSION_ROOT_DEPARTMENT = %r{^RSpec/}.freeze
+      COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/'
 
       def initialize(config, descriptions)
         @config       = config
@@ -15,21 +15,34 @@ def initialize(config, descriptions)
       end
 
       def dump
-        YAML.dump(unified_config).gsub(NAMESPACES, "\n\\1")
+        YAML.dump(unified_config)
+          .gsub(%r{^\w+/}, "\n\\0")   # Add an extra newline before each cop.
+          .gsub(/^(\s+)- /, '\1  - ') # Add 2 spaces before each array element.
+          .gsub('"~"', '~')           # Don't quote tilde, YAML's null value.
       end
 
       private
 
       def unified_config
         cops.each_with_object(config.dup) do |cop, unified|
-          unified[cop] = config.fetch(cop)
-            .merge(descriptions.fetch(cop))
-            .merge('StyleGuide' => STYLE_GUIDE_BASE_URL + cop.sub('RSpec/', ''))
+          replace_nil(unified[cop])
+          unified[cop].merge!(descriptions.fetch(cop))
+          unified[cop]['Reference'] = reference(cop)
         end
       end
 
       def cops
-        (descriptions.keys | config.keys).grep(NAMESPACES)
+        (descriptions.keys | config.keys).grep(EXTENSION_ROOT_DEPARTMENT)
+      end
+
+      def replace_nil(config)
+        config.each do |key, value|
+          config[key] = '~' if value.nil?
+        end
+      end
+
+      def reference(cop)
+        COP_DOC_BASE_URL + cop
       end
 
       attr_reader :config, :descriptions
diff --git a/lib/rubocop/rspec/cop/generator.rb b/lib/rubocop/rspec/cop/generator.rb
new file mode 100644
index 000000000..e571d3ae3
--- /dev/null
+++ b/lib/rubocop/rspec/cop/generator.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    module Cop
+      # Source and spec generator for new cops
+      #
+      # This generator will take a cop name and generate a source file
+      # and spec file when given a valid qualified cop name.
+      # @api private
+      class Generator < RuboCop::Cop::Generator
+        def todo
+          <<~TODO
+            Do 4 steps:
+              1. Modify the description of #{badge} in config/default.yml
+              2. Implement your new cop in the generated file!
+              3. Add an entry about new cop to CHANGELOG.md
+              4. Commit your new cop with a message such as
+                 e.g. "Add new `#{badge}` cop"
+          TODO
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/rspec/corrector/move_node.rb b/lib/rubocop/rspec/corrector/move_node.rb
new file mode 100644
index 000000000..3e07e49d5
--- /dev/null
+++ b/lib/rubocop/rspec/corrector/move_node.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    module Corrector
+      # Helper methods to move a node
+      class MoveNode
+        include RuboCop::Cop::RangeHelp
+        include RuboCop::Cop::RSpec::CommentsHelp
+        include RuboCop::Cop::RSpec::FinalEndLocation
+
+        attr_reader :original, :corrector, :processed_source
+
+        def initialize(node, corrector, processed_source)
+          @original = node
+          @corrector = corrector
+          @processed_source = processed_source # used by RangeHelp
+        end
+
+        def move_before(other)
+          position = start_line_position(other)
+
+          corrector.insert_before(position, "#{source(original)}\n")
+          corrector.remove(node_range_with_surrounding_space(original))
+        end
+
+        def move_after(other)
+          position = end_line_position(other)
+
+          corrector.insert_after(position, "\n#{source(original)}")
+          corrector.remove(node_range_with_surrounding_space(original))
+        end
+
+        private
+
+        def source(node)
+          node_range(node).source
+        end
+
+        def node_range(node)
+          source_range_with_comment(node)
+        end
+
+        def node_range_with_surrounding_space(node)
+          range = node_range(node)
+          range_by_whole_lines(range, include_final_newline: true)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/rspec/description_extractor.rb b/lib/rubocop/rspec/description_extractor.rb
index ad1e0a793..20facb399 100644
--- a/lib/rubocop/rspec/description_extractor.rb
+++ b/lib/rubocop/rspec/description_extractor.rb
@@ -21,7 +21,8 @@ def to_h
 
       # Decorator of a YARD code object for working with documented rspec cops
       class CodeObject
-        COP_CLASS_NAMES = %w[RuboCop::Cop RuboCop::Cop::RSpec::Cop].freeze
+        RSPEC_COP_CLASS_NAME = 'RuboCop::Cop::RSpec::Base'
+        RUBOCOP_COP_CLASS_NAME = 'RuboCop::Cop::Base'
         RSPEC_NAMESPACE = 'RuboCop::Cop::RSpec'
 
         def initialize(yardoc)
@@ -32,10 +33,7 @@ def initialize(yardoc)
         #
         # @return [Boolean]
         def rspec_cop?
-          class_documentation? &&
-            rspec_cop_namespace? &&
-            cop_subclass? &&
-            !abstract?
+          cop_subclass? && !abstract? && rspec_cop_namespace?
         end
 
         # Configuration for the documented cop that would live in default.yml
@@ -55,10 +53,6 @@ def description
           yardoc.docstring.split("\n\n").first.to_s
         end
 
-        def class_documentation?
-          yardoc.type.equal?(:class)
-        end
-
         def rspec_cop_namespace?
           documented_constant.start_with?(RSPEC_NAMESPACE)
         end
@@ -68,11 +62,8 @@ def documented_constant
         end
 
         def cop_subclass?
-          # YARD superclass resolution is a bit flaky: All classes loaded before
-          # RuboCop::Cop::WorkaroundCop are shown as having RuboCop::Cop as
-          # superclass, while all the following classes are listed as having
-          # RuboCop::Cop::RSpec::Cop as their superclass.
-          COP_CLASS_NAMES.include?(yardoc.superclass.path)
+          [RSPEC_COP_CLASS_NAME,
+           RUBOCOP_COP_CLASS_NAME].include?(yardoc.superclass.path)
         end
 
         def abstract?
diff --git a/lib/rubocop/rspec/example.rb b/lib/rubocop/rspec/example.rb
index a5af1469d..ff008d840 100644
--- a/lib/rubocop/rspec/example.rb
+++ b/lib/rubocop/rspec/example.rb
@@ -4,8 +4,13 @@ module RuboCop
   module RSpec
     # Wrapper for RSpec examples
     class Example < Concept
+      # @!method extract_doc_string(node)
       def_node_matcher :extract_doc_string,     '(send _ _ $_ ...)'
+
+      # @!method extract_metadata(node)
       def_node_matcher :extract_metadata,       '(send _ _ _ $...)'
+
+      # @!method extract_implementation(node)
       def_node_matcher :extract_implementation, '(block send args $_)'
 
       def doc_string
diff --git a/lib/rubocop/rspec/example_group.rb b/lib/rubocop/rspec/example_group.rb
index 8a88ed3f0..30f1ab49d 100644
--- a/lib/rubocop/rspec/example_group.rb
+++ b/lib/rubocop/rspec/example_group.rb
@@ -10,76 +10,56 @@ class ExampleGroup < Concept
       #
       #   Selectors which indicate that we should stop searching
       #
-      def_node_matcher :scope_change?, (
-        ExampleGroups::ALL + SharedGroups::ALL + Includes::ALL
-      ).block_pattern
+      def_node_matcher :scope_change?, <<~PATTERN
+        (block {
+          (send #rspec? {#SharedGroups.all #ExampleGroups.all} ...)
+          (send nil? #Includes.all ...)
+        } ...)
+      PATTERN
 
-      def subjects
-        subjects_in_scope(node)
-      end
-
-      def examples
-        examples_in_scope(node).map(&Example.public_method(:new))
-      end
-
-      def hooks
-        hooks_in_scope(node).map(&Hook.public_method(:new))
-      end
-
-      private
-
-      def subjects_in_scope(node)
-        node.each_child_node.flat_map do |child|
-          find_subjects(child)
-        end
+      def lets
+        find_all_in_scope(node, :let?)
       end
 
-      def find_subjects(node)
-        return [] if scope_change?(node)
-
-        if subject?(node)
-          [node]
-        else
-          subjects_in_scope(node)
-        end
+      def subjects
+        find_all_in_scope(node, :subject?)
       end
 
-      def hooks_in_scope(node)
-        node.each_child_node.flat_map do |child|
-          find_hooks(child)
+      def examples
+        find_all_in_scope(node, :example?).map do |node|
+          Example.new(node)
         end
       end
 
-      def find_hooks(node)
-        return [] if scope_change?(node) || example?(node)
-
-        if hook?(node)
-          [node]
-        else
-          hooks_in_scope(node)
+      def hooks
+        find_all_in_scope(node, :hook?).map do |node|
+          Hook.new(node)
         end
       end
 
-      def examples_in_scope(node, &blk)
-        node.each_child_node.flat_map do |child|
-          find_examples(child, &blk)
-        end
-      end
+      private
 
-      # Recursively search for examples within the current scope
+      # Recursively search for predicate within the current scope
       #
-      # Searches node for examples and halts when a scope change is detected
+      # Searches node and halts when a scope change is detected
       #
-      # @param node [RuboCop::Node] node to recursively search for examples
+      # @param node [RuboCop::AST::Node] node to recursively search
+      # @param predicate [Symbol] method to call with node as argument
       #
-      # @return [Array<RuboCop::Node>] discovered example nodes
-      def find_examples(node)
-        return [] if scope_change?(node)
+      # @return [Array<RuboCop::AST::Node>] discovered nodes
+      def find_all_in_scope(node, predicate)
+        node.each_child_node.flat_map do |child|
+          find_all(child, predicate)
+        end
+      end
 
-        if example?(node)
+      def find_all(node, predicate)
+        if public_send(predicate, node)
           [node]
+        elsif scope_change?(node) || example?(node)
+          []
         else
-          examples_in_scope(node)
+          find_all_in_scope(node, predicate)
         end
       end
     end
diff --git a/lib/rubocop/rspec/factory_bot.rb b/lib/rubocop/rspec/factory_bot.rb
deleted file mode 100644
index 539bcf70c..000000000
--- a/lib/rubocop/rspec/factory_bot.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # RuboCop FactoryBot project namespace
-    module FactoryBot
-      ATTRIBUTE_DEFINING_METHODS = %i[factory trait transient ignore].freeze
-
-      UNPROXIED_METHODS = %i[
-        __send__
-        __id__
-        nil?
-        send
-        object_id
-        extend
-        instance_eval
-        initialize
-        block_given?
-        raise
-        caller
-        method
-      ].freeze
-
-      DEFINITION_PROXY_METHODS = %i[
-        add_attribute
-        after
-        association
-        before
-        callback
-        ignore
-        initialize_with
-        sequence
-        skip_create
-        to_create
-      ].freeze
-
-      RESERVED_METHODS =
-        DEFINITION_PROXY_METHODS +
-        UNPROXIED_METHODS +
-        ATTRIBUTE_DEFINING_METHODS
-
-      private_constant(
-        :ATTRIBUTE_DEFINING_METHODS,
-        :UNPROXIED_METHODS,
-        :DEFINITION_PROXY_METHODS,
-        :RESERVED_METHODS
-      )
-
-      def self.attribute_defining_methods
-        ATTRIBUTE_DEFINING_METHODS
-      end
-
-      def self.reserved_methods
-        RESERVED_METHODS
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/final_end_location.rb b/lib/rubocop/rspec/final_end_location.rb
deleted file mode 100644
index ce481a939..000000000
--- a/lib/rubocop/rspec/final_end_location.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Helps find the true end location of nodes which might contain heredocs.
-    module FinalEndLocation
-      def final_end_location(start_node)
-        heredoc_endings =
-          start_node.each_node(:str, :dstr, :xstr)
-            .select(&:heredoc?)
-            .map { |node| node.loc.heredoc_end }
-
-        [start_node.loc.end, *heredoc_endings].max_by(&:line)
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/hook.rb b/lib/rubocop/rspec/hook.rb
index 5dc6d744e..4c2995aa7 100644
--- a/lib/rubocop/rspec/hook.rb
+++ b/lib/rubocop/rspec/hook.rb
@@ -4,13 +4,10 @@ module RuboCop
   module RSpec
     # Wrapper for RSpec hook
     class Hook < Concept
+      # @!method extract_metadata(node)
       def_node_matcher :extract_metadata, <<~PATTERN
         (block
-          {
-            (send _ _ #valid_scope? $...)
-            (send _ _ $...)
-          }
-          ...
+          (send _ _ #valid_scope? ? $...) ...
         )
       PATTERN
 
@@ -48,7 +45,7 @@ def metadata
       private
 
       def valid_scope?(node)
-        node&.sym_type? && Hooks::Scopes::ALL.include?(node.value)
+        node.sym_type? && Language::HookScopes.all(node.value)
       end
 
       def transform_metadata(meta)
@@ -67,7 +64,9 @@ def transform_metadata(meta)
       end
 
       def transform_true(node)
-        node.true_type? ? true : node
+        return true if node.true_type?
+
+        node
       end
 
       def scope_name
diff --git a/lib/rubocop/rspec/inject.rb b/lib/rubocop/rspec/inject.rb
deleted file mode 100644
index 659ca8f11..000000000
--- a/lib/rubocop/rspec/inject.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/language.rb b/lib/rubocop/rspec/language.rb
index 60e182a82..b7c46a654 100644
--- a/lib/rubocop/rspec/language.rb
+++ b/lib/rubocop/rspec/language.rb
@@ -2,137 +2,212 @@
 
 module RuboCop
   module RSpec
-    # RSpec public API methods that are commonly used in cops
+    # Contains node matchers for common RSpec DSL.
+    #
+    # RSpec allows for configuring aliases for commonly used DSL elements, e.g.
+    # example groups and hooks. It is possible to configure RuboCop RSpec to
+    # be able to properly detect these elements in the `RSpec/Language` section
+    # of the RuboCop YAML configuration file.
+    #
+    # In addition to providing useful matchers, this class is responsible for
+    # using the configured aliases.
     module Language
-      RSPEC = '{(const {nil? cbase} :RSpec) nil?}'
+      extend RuboCop::NodePattern::Macros
 
-      # Set of method selectors
-      class SelectorSet
-        def initialize(selectors)
-          @selectors = selectors
-        end
-
-        def ==(other)
-          selectors.eql?(other.selectors)
-        end
-
-        def +(other)
-          self.class.new(selectors + other.selectors)
-        end
+      class << self
+        attr_accessor :config
+      end
 
-        def include?(selector)
-          selectors.include?(selector)
+      # @!method rspec?(node)
+      def_node_matcher :rspec?, '{#explicit_rspec? nil?}'
+
+      # @!method explicit_rspec?(node)
+      def_node_matcher :explicit_rspec?, '(const {nil? cbase} :RSpec)'
+
+      # @!method example_group?(node)
+      def_node_matcher :example_group?, <<~PATTERN
+        (any_block (send #rspec? #ExampleGroups.all ...) ...)
+      PATTERN
+
+      # @!method shared_group?(node)
+      def_node_matcher :shared_group?,
+                       '(block (send #rspec? #SharedGroups.all ...) ...)'
+
+      # @!method spec_group?(node)
+      def_node_matcher :spec_group?, <<~PATTERN
+        (any_block (send #rspec?
+             {#SharedGroups.all #ExampleGroups.all}
+          ...) ...)
+      PATTERN
+
+      # @!method example_group_with_body?(node)
+      def_node_matcher :example_group_with_body?, <<~PATTERN
+        (block (send #rspec? #ExampleGroups.all ...) args !nil?)
+      PATTERN
+
+      # @!method example?(node)
+      def_node_matcher :example?, '(block (send nil? #Examples.all ...) ...)'
+
+      # @!method hook?(node)
+      def_node_matcher :hook?, <<~PATTERN
+        (any_block (send nil? #Hooks.all ...) ...)
+      PATTERN
+
+      # @!method let?(node)
+      def_node_matcher :let?, <<~PATTERN
+        {
+          (block (send nil? #Helpers.all ...) ...)
+          (send nil? #Helpers.all _ block_pass)
+        }
+      PATTERN
+
+      # @!method include?(node)
+      def_node_matcher :include?, <<~PATTERN
+        {
+          (block (send nil? #Includes.all ...) ...)
+          (send nil? #Includes.all ...)
+        }
+      PATTERN
+
+      # @!method subject?(node)
+      def_node_matcher :subject?, '(block (send nil? #Subjects.all ...) ...)'
+
+      module ExampleGroups # :nodoc:
+        class << self
+          def all(element)
+            regular(element) ||
+              skipped(element) ||
+              focused(element)
+          end
+
+          def regular(element)
+            Language.config['ExampleGroups']['Regular'].include?(element.to_s)
+          end
+
+          def focused(element)
+            Language.config['ExampleGroups']['Focused'].include?(element.to_s)
+          end
+
+          def skipped(element)
+            Language.config['ExampleGroups']['Skipped'].include?(element.to_s)
+          end
         end
+      end
 
-        def block_pattern
-          "(block #{send_pattern} ...)"
+      module Examples # :nodoc:
+        class << self
+          def all(element)
+            regular(element) ||
+              focused(element) ||
+              skipped(element) ||
+              pending(element)
+          end
+
+          def regular(element)
+            Language.config['Examples']['Regular'].include?(element.to_s)
+          end
+
+          def focused(element)
+            Language.config['Examples']['Focused'].include?(element.to_s)
+          end
+
+          def skipped(element)
+            Language.config['Examples']['Skipped'].include?(element.to_s)
+          end
+
+          def pending(element)
+            Language.config['Examples']['Pending'].include?(element.to_s)
+          end
         end
+      end
 
-        def send_pattern
-          "(send #{RSPEC} #{node_pattern_union} ...)"
+      module Expectations # :nodoc:
+        def self.all(element)
+          Language.config['Expectations'].include?(element.to_s)
         end
+      end
 
-        def node_pattern_union
-          "{#{node_pattern}}"
+      module Helpers # :nodoc:
+        def self.all(element)
+          Language.config['Helpers'].include?(element.to_s)
         end
+      end
 
-        def node_pattern
-          selectors.map(&:inspect).join(' ')
+      module Hooks # :nodoc:
+        def self.all(element)
+          Language.config['Hooks'].include?(element.to_s)
         end
-
-        protected
-
-        attr_reader :selectors
       end
 
-      module ExampleGroups
-        GROUPS  = SelectorSet.new(%i[describe context feature example_group])
-        SKIPPED = SelectorSet.new(%i[xdescribe xcontext xfeature])
-        FOCUSED = SelectorSet.new(%i[fdescribe fcontext ffeature])
-
-        ALL = GROUPS + SKIPPED + FOCUSED
+      module HookScopes # :nodoc:
+        ALL = %i[each example context all suite].freeze
+        def self.all(element)
+          ALL.include?(element)
+        end
       end
 
-      module SharedGroups
-        EXAMPLES = SelectorSet.new(%i[shared_examples shared_examples_for])
-        CONTEXT = SelectorSet.new(%i[shared_context])
+      module Includes # :nodoc:
+        class << self
+          def all(element)
+            examples(element) ||
+              context(element)
+          end
 
-        ALL = EXAMPLES + CONTEXT
-      end
+          def examples(element)
+            Language.config['Includes']['Examples'].include?(element.to_s)
+          end
 
-      module Includes
-        EXAMPLES = SelectorSet.new(
-          %i[
-            it_behaves_like
-            it_should_behave_like
-            include_examples
-          ]
-        )
-        CONTEXT = SelectorSet.new(%i[include_context])
-
-        ALL = EXAMPLES + CONTEXT
+          def context(element)
+            Language.config['Includes']['Context'].include?(element.to_s)
+          end
+        end
       end
 
-      module Examples
-        EXAMPLES = SelectorSet.new(%i[it specify example scenario its])
-        FOCUSED  = SelectorSet.new(%i[fit fspecify fexample fscenario focus])
-        SKIPPED  = SelectorSet.new(%i[xit xspecify xexample xscenario skip])
-        PENDING  = SelectorSet.new(%i[pending])
-
-        ALL = EXAMPLES + FOCUSED + SKIPPED + PENDING
-      end
+      module Runners # :nodoc:
+        ALL = %i[to to_not not_to].freeze
+        class << self
+          def all(element = nil)
+            return ALL if element.nil?
 
-      module Hooks
-        ALL = SelectorSet.new(
-          %i[
-            prepend_before
-            before
-            append_before
-            around
-            prepend_after
-            after
-            append_after
-          ]
-        )
-
-        module Scopes
-          ALL = SelectorSet.new(
-            %i[
-              each
-              example
-              context
-              all
-              suite
-            ]
-          )
+            ALL.include?(element)
+          end
         end
       end
 
-      module Helpers
-        ALL = SelectorSet.new(%i[let let!])
-      end
+      module SharedGroups # :nodoc:
+        class << self
+          def all(element)
+            examples(element) ||
+              context(element)
+          end
+
+          def examples(element)
+            Language.config['SharedGroups']['Examples'].include?(element.to_s)
+          end
 
-      module Subject
-        ALL = SelectorSet.new(%i[subject subject!])
+          def context(element)
+            Language.config['SharedGroups']['Context'].include?(element.to_s)
+          end
+        end
       end
 
-      module Expectations
-        ALL = SelectorSet.new(%i[expect is_expected expect_any_instance_of])
+      module Subjects # :nodoc:
+        def self.all(element)
+          Language.config['Subjects'].include?(element.to_s)
+        end
       end
 
-      module Runners
-        ALL = SelectorSet.new(%i[to to_not not_to])
+      # This is used in Dialect and DescribeClass cops to detect RSpec blocks.
+      module ALL # :nodoc:
+        def self.all(element)
+          [ExampleGroups, Examples, Expectations, Helpers, Hooks, Includes,
+           Runners, SharedGroups, Subjects]
+            .find { |concept| concept.all(element) }
+        end
       end
 
-      ALL =
-        ExampleGroups::ALL +
-        SharedGroups::ALL  +
-        Examples::ALL      +
-        Hooks::ALL         +
-        Helpers::ALL       +
-        Subject::ALL       +
-        Expectations::ALL  +
-        Runners::ALL
+      private_constant :ExampleGroups, :Examples, :Expectations, :Hooks,
+                       :Includes, :Runners, :SharedGroups, :ALL
     end
   end
 end
diff --git a/lib/rubocop/rspec/language/node_pattern.rb b/lib/rubocop/rspec/language/node_pattern.rb
deleted file mode 100644
index 63378fd42..000000000
--- a/lib/rubocop/rspec/language/node_pattern.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    module Language
-      # Common node matchers used for matching against the rspec DSL
-      module NodePattern
-        extend RuboCop::NodePattern::Macros
-
-        def_node_matcher :example_group?, ExampleGroups::ALL.block_pattern
-
-        def_node_matcher :example_group_with_body?, <<-PATTERN
-          (block #{ExampleGroups::ALL.send_pattern} args [!nil?])
-        PATTERN
-
-        def_node_matcher :example?, Examples::ALL.block_pattern
-
-        def_node_matcher :hook?, Hooks::ALL.block_pattern
-
-        def_node_matcher :let?, Helpers::ALL.block_pattern
-
-        def_node_matcher :subject?, Subject::ALL.block_pattern
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/node.rb b/lib/rubocop/rspec/node.rb
index 5281dfaf4..0dc6a2d42 100644
--- a/lib/rubocop/rspec/node.rb
+++ b/lib/rubocop/rspec/node.rb
@@ -2,14 +2,14 @@
 
 module RuboCop
   module RSpec
-    # RuboCop-RSpec specific extensions of RuboCop::AST::Node
+    # RuboCop RSpec specific extensions of RuboCop::AST::Node
     module Node
-      # In various cops we want to regard const as literal althought it's not
+      # In various cops we want to regard const as literal although it's not
       # strictly literal.
       def recursive_literal_or_const?
         case type
         when :begin, :pair, *AST::Node::COMPOSITE_LITERALS
-          children.all?(&:recursive_literal_or_const?)
+          children.compact.all?(&:recursive_literal_or_const?)
         else
           literal? || const_type?
         end
diff --git a/lib/rubocop/rspec/plugin.rb b/lib/rubocop/rspec/plugin.rb
new file mode 100644
index 000000000..88d48cf0c
--- /dev/null
+++ b/lib/rubocop/rspec/plugin.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module RSpec
+    # A plugin that integrates RuboCop RSpec with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      # :nocov:
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-rspec',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop-rspec',
+          description: 'Code style checking for RSpec files.'
+        )
+      end
+      # :nocov:
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+
+        ConfigObsoletion.files << project_root.join('config', 'obsoletion.yml')
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: project_root.join('config/default.yml')
+        )
+      end
+    end
+  end
+end
diff --git a/lib/rubocop/rspec/shared_contexts/default_rspec_language_config_context.rb b/lib/rubocop/rspec/shared_contexts/default_rspec_language_config_context.rb
new file mode 100644
index 000000000..f130fdb4d
--- /dev/null
+++ b/lib/rubocop/rspec/shared_contexts/default_rspec_language_config_context.rb
@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'with default RSpec/Language config' do
+  include_context 'config'
+
+  # Deep duplication is needed to prevent config leakage between examples
+  let(:other_cops) do
+    default_language = RuboCop::ConfigLoader
+      .default_configuration['RSpec']['Language']
+    default_include = RuboCop::ConfigLoader
+      .default_configuration['RSpec']['Include']
+    { 'RSpec' =>
+      {
+        'Include' => default_include,
+        'Language' => deep_dup(default_language)
+      } }
+  end
+
+  def deep_dup(object)
+    case object
+    when Array
+      object.map { |item| deep_dup(item) }
+    when Hash
+      object.transform_values { |value| deep_dup(value) }
+    else
+      object # only collections undergo modifications and need duping
+    end
+  end
+end
diff --git a/lib/rubocop/rspec/top_level_describe.rb b/lib/rubocop/rspec/top_level_describe.rb
deleted file mode 100644
index 4502ae27d..000000000
--- a/lib/rubocop/rspec/top_level_describe.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module RSpec
-    # Helper methods for top level describe cops
-    module TopLevelDescribe
-      extend NodePattern::Macros
-
-      def on_send(node)
-        return unless respond_to?(:on_top_level_describe)
-        return unless top_level_describe?(node)
-
-        on_top_level_describe(node, node.arguments)
-      end
-
-      private
-
-      def top_level_describe?(node)
-        return false unless node.method_name == :describe
-
-        top_level_nodes.include?(node)
-      end
-
-      def top_level_nodes
-        nodes = describe_statement_children(root_node)
-        # If we have no top level describe statements, we need to check any
-        # blocks on the top level (e.g. after a require).
-        if nodes.empty?
-          nodes = root_node.each_child_node(:block).flat_map do |child|
-            describe_statement_children(child)
-          end
-        end
-
-        nodes
-      end
-
-      def root_node
-        processed_source.ast
-      end
-
-      def single_top_level_describe?
-        top_level_nodes.one?
-      end
-
-      def describe_statement_children(node)
-        node.each_child_node(:send).select do |element|
-          element.method_name == :describe
-        end
-      end
-    end
-  end
-end
diff --git a/lib/rubocop/rspec/version.rb b/lib/rubocop/rspec/version.rb
index 534d90e10..f8db04c2c 100644
--- a/lib/rubocop/rspec/version.rb
+++ b/lib/rubocop/rspec/version.rb
@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Version information for the RSpec RuboCop plugin.
     module Version
-      STRING = '1.38.1'
+      STRING = '3.6.0'
     end
   end
 end
diff --git a/lib/rubocop/rspec/wording.rb b/lib/rubocop/rspec/wording.rb
index 736c54f48..eca36fccc 100644
--- a/lib/rubocop/rspec/wording.rb
+++ b/lib/rubocop/rspec/wording.rb
@@ -4,8 +4,10 @@ module RuboCop
   module RSpec
     # RSpec example wording rewriter
     class Wording
-      SHOULDNT_PREFIX    = /\Ashould(?:n't| not)\b/i.freeze
+      SHOULDNT_PREFIX    = /\Ashould(?:n't|n’t| not)\b/i.freeze
       SHOULDNT_BE_PREFIX = /#{SHOULDNT_PREFIX} be\b/i.freeze
+      WILL_NOT_PREFIX    = /\Awill not\b/i.freeze
+      WONT_PREFIX        = /\Awo(?:n't|n’t)\b/i.freeze
       ES_SUFFIX_PATTERN  = /(?:o|s|x|ch|sh|z)\z/i.freeze
       IES_SUFFIX_PATTERN = /[^aeou]y\z/i.freeze
 
@@ -21,6 +23,10 @@ def rewrite
           replace_prefix(SHOULDNT_BE_PREFIX, 'is not')
         when SHOULDNT_PREFIX
           replace_prefix(SHOULDNT_PREFIX, 'does not')
+        when WILL_NOT_PREFIX
+          replace_prefix(WILL_NOT_PREFIX, 'does not')
+        when WONT_PREFIX
+          replace_prefix(WONT_PREFIX, 'does not')
         else
           remove_should_and_pluralize
         end
@@ -31,8 +37,8 @@ def rewrite
       attr_reader :text, :ignores, :replacements
 
       def replace_prefix(pattern, replacement)
-        text.sub(pattern) do |shouldnt|
-          uppercase?(shouldnt) ? replacement.upcase : replacement
+        text.sub(pattern) do |matched|
+          uppercase?(matched) ? replacement.upcase : replacement
         end
       end
 
diff --git a/manual/cops.md b/manual/cops.md
deleted file mode 100644
index a5a62faad..000000000
--- a/manual/cops.md
+++ /dev/null
@@ -1,94 +0,0 @@
-<!-- START_COP_LIST -->
-#### Department [Capybara](cops_capybara.md)
-
-* [Capybara/CurrentPathExpectation](cops_capybara.md#capybaracurrentpathexpectation)
-* [Capybara/FeatureMethods](cops_capybara.md#capybarafeaturemethods)
-
-#### Department [FactoryBot](cops_factorybot.md)
-
-* [FactoryBot/AttributeDefinedStatically](cops_factorybot.md#factorybotattributedefinedstatically)
-* [FactoryBot/CreateList](cops_factorybot.md#factorybotcreatelist)
-* [FactoryBot/FactoryClassName](cops_factorybot.md#factorybotfactoryclassname)
-
-#### Department [RSpec](cops_rspec.md)
-
-* [RSpec/AlignLeftLetBrace](cops_rspec.md#rspecalignleftletbrace)
-* [RSpec/AlignRightLetBrace](cops_rspec.md#rspecalignrightletbrace)
-* [RSpec/AnyInstance](cops_rspec.md#rspecanyinstance)
-* [RSpec/AroundBlock](cops_rspec.md#rspecaroundblock)
-* [RSpec/Be](cops_rspec.md#rspecbe)
-* [RSpec/BeEql](cops_rspec.md#rspecbeeql)
-* [RSpec/BeforeAfterAll](cops_rspec.md#rspecbeforeafterall)
-* [RSpec/ContextMethod](cops_rspec.md#rspeccontextmethod)
-* [RSpec/ContextWording](cops_rspec.md#rspeccontextwording)
-* [RSpec/DescribeClass](cops_rspec.md#rspecdescribeclass)
-* [RSpec/DescribeMethod](cops_rspec.md#rspecdescribemethod)
-* [RSpec/DescribeSymbol](cops_rspec.md#rspecdescribesymbol)
-* [RSpec/DescribedClass](cops_rspec.md#rspecdescribedclass)
-* [RSpec/DescribedClassModuleWrapping](cops_rspec.md#rspecdescribedclassmodulewrapping)
-* [RSpec/Dialect](cops_rspec.md#rspecdialect)
-* [RSpec/EmptyExampleGroup](cops_rspec.md#rspecemptyexamplegroup)
-* [RSpec/EmptyLineAfterExample](cops_rspec.md#rspecemptylineafterexample)
-* [RSpec/EmptyLineAfterExampleGroup](cops_rspec.md#rspecemptylineafterexamplegroup)
-* [RSpec/EmptyLineAfterFinalLet](cops_rspec.md#rspecemptylineafterfinallet)
-* [RSpec/EmptyLineAfterHook](cops_rspec.md#rspecemptylineafterhook)
-* [RSpec/EmptyLineAfterSubject](cops_rspec.md#rspecemptylineaftersubject)
-* [RSpec/ExampleLength](cops_rspec.md#rspecexamplelength)
-* [RSpec/ExampleWithoutDescription](cops_rspec.md#rspecexamplewithoutdescription)
-* [RSpec/ExampleWording](cops_rspec.md#rspecexamplewording)
-* [RSpec/ExpectActual](cops_rspec.md#rspecexpectactual)
-* [RSpec/ExpectChange](cops_rspec.md#rspecexpectchange)
-* [RSpec/ExpectInHook](cops_rspec.md#rspecexpectinhook)
-* [RSpec/ExpectOutput](cops_rspec.md#rspecexpectoutput)
-* [RSpec/FilePath](cops_rspec.md#rspecfilepath)
-* [RSpec/Focus](cops_rspec.md#rspecfocus)
-* [RSpec/HookArgument](cops_rspec.md#rspechookargument)
-* [RSpec/HooksBeforeExamples](cops_rspec.md#rspechooksbeforeexamples)
-* [RSpec/ImplicitBlockExpectation](cops_rspec.md#rspecimplicitblockexpectation)
-* [RSpec/ImplicitExpect](cops_rspec.md#rspecimplicitexpect)
-* [RSpec/ImplicitSubject](cops_rspec.md#rspecimplicitsubject)
-* [RSpec/InstanceSpy](cops_rspec.md#rspecinstancespy)
-* [RSpec/InstanceVariable](cops_rspec.md#rspecinstancevariable)
-* [RSpec/InvalidPredicateMatcher](cops_rspec.md#rspecinvalidpredicatematcher)
-* [RSpec/ItBehavesLike](cops_rspec.md#rspecitbehaveslike)
-* [RSpec/IteratedExpectation](cops_rspec.md#rspeciteratedexpectation)
-* [RSpec/LeadingSubject](cops_rspec.md#rspecleadingsubject)
-* [RSpec/LeakyConstantDeclaration](cops_rspec.md#rspecleakyconstantdeclaration)
-* [RSpec/LetBeforeExamples](cops_rspec.md#rspecletbeforeexamples)
-* [RSpec/LetSetup](cops_rspec.md#rspecletsetup)
-* [RSpec/MessageChain](cops_rspec.md#rspecmessagechain)
-* [RSpec/MessageExpectation](cops_rspec.md#rspecmessageexpectation)
-* [RSpec/MessageSpies](cops_rspec.md#rspecmessagespies)
-* [RSpec/MissingExampleGroupArgument](cops_rspec.md#rspecmissingexamplegroupargument)
-* [RSpec/MultipleDescribes](cops_rspec.md#rspecmultipledescribes)
-* [RSpec/MultipleExpectations](cops_rspec.md#rspecmultipleexpectations)
-* [RSpec/MultipleSubjects](cops_rspec.md#rspecmultiplesubjects)
-* [RSpec/NamedSubject](cops_rspec.md#rspecnamedsubject)
-* [RSpec/NestedGroups](cops_rspec.md#rspecnestedgroups)
-* [RSpec/NotToNot](cops_rspec.md#rspecnottonot)
-* [RSpec/OverwritingSetup](cops_rspec.md#rspecoverwritingsetup)
-* [RSpec/Pending](cops_rspec.md#rspecpending)
-* [RSpec/PredicateMatcher](cops_rspec.md#rspecpredicatematcher)
-* [RSpec/ReceiveCounts](cops_rspec.md#rspecreceivecounts)
-* [RSpec/ReceiveNever](cops_rspec.md#rspecreceivenever)
-* [RSpec/RepeatedDescription](cops_rspec.md#rspecrepeateddescription)
-* [RSpec/RepeatedExample](cops_rspec.md#rspecrepeatedexample)
-* [RSpec/RepeatedExampleGroupBody](cops_rspec.md#rspecrepeatedexamplegroupbody)
-* [RSpec/RepeatedExampleGroupDescription](cops_rspec.md#rspecrepeatedexamplegroupdescription)
-* [RSpec/ReturnFromStub](cops_rspec.md#rspecreturnfromstub)
-* [RSpec/ScatteredLet](cops_rspec.md#rspecscatteredlet)
-* [RSpec/ScatteredSetup](cops_rspec.md#rspecscatteredsetup)
-* [RSpec/SharedContext](cops_rspec.md#rspecsharedcontext)
-* [RSpec/SharedExamples](cops_rspec.md#rspecsharedexamples)
-* [RSpec/SingleArgumentMessageChain](cops_rspec.md#rspecsingleargumentmessagechain)
-* [RSpec/SubjectStub](cops_rspec.md#rspecsubjectstub)
-* [RSpec/UnspecifiedException](cops_rspec.md#rspecunspecifiedexception)
-* [RSpec/VerifiedDoubles](cops_rspec.md#rspecverifieddoubles)
-* [RSpec/VoidExpect](cops_rspec.md#rspecvoidexpect)
-* [RSpec/Yield](cops_rspec.md#rspecyield)
-
-#### Department [Rails](cops_rails.md)
-
-* [Rails/HttpStatus](cops_rails.md#railshttpstatus)
-
-<!-- END_COP_LIST -->
diff --git a/manual/cops_capybara.md b/manual/cops_capybara.md
deleted file mode 100644
index c4f60f9cb..000000000
--- a/manual/cops_capybara.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Capybara
-
-## Capybara/CurrentPathExpectation
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks that no expectations are set on Capybara's `current_path`.
-
-The `have_current_path` matcher (https://www.rubydoc.info/github/
-teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-
-instance_method) should be used on `page` to set expectations on
-Capybara's current path, since it uses Capybara's waiting
-functionality (https://github.com/teamcapybara/capybara/blob/master/
-README.md#asynchronous-javascript-ajax-and-friends) which ensures that
-preceding actions (like `click_link`) have completed.
-
-### Examples
-
-```ruby
-# bad
-expect(current_path).to eq('/callback')
-expect(page.current_path).to match(/widgets/)
-
-# good
-expect(page).to have_current_path("/callback")
-expect(page).to have_current_path(/widgets/)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/CurrentPathExpectation](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/CurrentPathExpectation)
-
-## Capybara/FeatureMethods
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for consistent method usage in feature specs.
-
-By default, the cop disables all Capybara-specific methods that have
-the same native RSpec method (e.g. are just aliases). Some teams
-however may prefer using some of the Capybara methods (like `feature`)
-to make it obvious that the test uses Capybara, while still disable
-the rest of the methods, like `given` (alias for `let`), `background`
-(alias for `before`), etc. You can configure which of the methods to
-be enabled by using the EnabledMethods configuration option.
-
-### Examples
-
-```ruby
-# bad
-feature 'User logs in' do
-  given(:user) { User.new }
-
-  background do
-    visit new_session_path
-  end
-
-  scenario 'with OAuth' do
-    # ...
-  end
-end
-
-# good
-describe 'User logs in' do
-  let(:user) { User.new }
-
-  before do
-    visit new_session_path
-  end
-
-  it 'with OAuth' do
-    # ...
-  end
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnabledMethods | `[]` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods)
diff --git a/manual/cops_factorybot.md b/manual/cops_factorybot.md
deleted file mode 100644
index 91312ae59..000000000
--- a/manual/cops_factorybot.md
+++ /dev/null
@@ -1,108 +0,0 @@
-# FactoryBot
-
-## FactoryBot/AttributeDefinedStatically
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Always declare attribute values as blocks.
-
-### Examples
-
-```ruby
-# bad
-kind [:active, :rejected].sample
-
-# good
-kind { [:active, :rejected].sample }
-
-# bad
-closed_at 1.day.from_now
-
-# good
-closed_at { 1.day.from_now }
-
-# bad
-count 1
-
-# good
-count { 1 }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/AttributeDefinedStatically](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/AttributeDefinedStatically)
-
-## FactoryBot/CreateList
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for create_list usage.
-
-This cop can be configured using the `EnforcedStyle` option
-
-### Examples
-
-#### `EnforcedStyle: create_list`
-
-```ruby
-# bad
-3.times { create :user }
-
-# good
-create_list :user, 3
-
-# good
-3.times { |n| create :user, created_at: n.months.ago }
-```
-#### `EnforcedStyle: n_times`
-
-```ruby
-# bad
-create_list :user, 3
-
-# good
-3.times { create :user }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `create_list` | `create_list`, `n_times`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/CreateList](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/CreateList)
-
-## FactoryBot/FactoryClassName
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Use string value when setting the class attribute explicitly.
-
-This cop would promote faster tests by lazy-loading of
-application files. Also, this could help you suppress potential bugs
-in combination with external libraries by avoiding a preload of
-application files from the factory files.
-
-### Examples
-
-```ruby
-# bad
-factory :foo, class: Foo do
-end
-
-# good
-factory :foo, class: 'Foo' do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/FactoryClassName](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FactoryBot/FactoryClassName)
diff --git a/manual/cops_rails.md b/manual/cops_rails.md
deleted file mode 100644
index 1f43d0ed3..000000000
--- a/manual/cops_rails.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Rails
-
-## Rails/HttpStatus
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Enforces use of symbolic or numeric value to describe HTTP status.
-
-### Examples
-
-#### `EnforcedStyle: symbolic` (default)
-
-```ruby
-# bad
-it { is_expected.to have_http_status 200 }
-it { is_expected.to have_http_status 404 }
-
-# good
-it { is_expected.to have_http_status :ok }
-it { is_expected.to have_http_status :not_found }
-it { is_expected.to have_http_status :success }
-it { is_expected.to have_http_status :error }
-```
-#### `EnforcedStyle: numeric`
-
-```ruby
-# bad
-it { is_expected.to have_http_status :ok }
-it { is_expected.to have_http_status :not_found }
-
-# good
-it { is_expected.to have_http_status 200 }
-it { is_expected.to have_http_status 404 }
-it { is_expected.to have_http_status :success }
-it { is_expected.to have_http_status :error }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `symbolic` | `numeric`, `symbolic`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HttpStatus](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Rails/HttpStatus)
diff --git a/manual/cops_rspec.md b/manual/cops_rspec.md
deleted file mode 100644
index fa2caddd7..000000000
--- a/manual/cops_rspec.md
+++ /dev/null
@@ -1,3047 +0,0 @@
-# RSpec
-
-## RSpec/AlignLeftLetBrace
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | Yes
-
-Checks that left braces for adjacent single line lets are aligned.
-
-### Examples
-
-```ruby
-# bad
-let(:foobar) { blahblah }
-let(:baz) { bar }
-let(:a) { b }
-
-# good
-let(:foobar) { blahblah }
-let(:baz)    { bar }
-let(:a)      { b }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignLeftLetBrace)
-
-## RSpec/AlignRightLetBrace
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | Yes
-
-Checks that right braces for adjacent single line lets are aligned.
-
-### Examples
-
-```ruby
-# bad
-let(:foobar) { blahblah }
-let(:baz)    { bar }
-let(:a)      { b }
-
-# good
-let(:foobar) { blahblah }
-let(:baz)    { bar      }
-let(:a)      { b        }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AlignRightLetBrace)
-
-## RSpec/AnyInstance
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that instances are not being stubbed globally.
-
-Prefer instance doubles over stubbing any instance of a class
-
-### Examples
-
-```ruby
-# bad
-describe MyClass do
-  before { allow_any_instance_of(MyClass).to receive(:foo) }
-end
-
-# good
-describe MyClass do
-  let(:my_instance) { instance_double(MyClass) }
-
-  before do
-    allow(MyClass).to receive(:new).and_return(my_instance)
-    allow(my_instance).to receive(:foo)
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AnyInstance)
-
-## RSpec/AroundBlock
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that around blocks actually run the test.
-
-### Examples
-
-```ruby
-# bad
-around do
-  some_method
-end
-
-around do |test|
-  some_method
-end
-
-# good
-around do |test|
-  some_method
-  test.call
-end
-
-around do |test|
-  some_method
-  test.run
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/AroundBlock)
-
-## RSpec/Be
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check for expectations where `be` is used without argument.
-
-The `be` matcher is too generic, as it pass on everything that is not
-nil or false. If that is the exact intend, use `be_truthy`. In all other
-cases it's better to specify what exactly is the expected value.
-
-### Examples
-
-```ruby
-# bad
-expect(foo).to be
-
-# good
-expect(foo).to be_truthy
-expect(foo).to be 1.0
-expect(foo).to be(true)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Be)
-
-## RSpec/BeEql
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Check for expectations where `be(...)` can replace `eql(...)`.
-
-The `be` matcher compares by identity while the `eql` matcher
-compares using `eql?`. Integers, floats, booleans, symbols, and nil
-can be compared by identity and therefore the `be` matcher is
-preferable as it is a more strict test.
-
-This cop only looks for instances of `expect(...).to eql(...)`. We
-do not check `to_not` or `not_to` since `!eql?` is more strict
-than `!equal?`. We also do not try to flag `eq` because if
-`a == b`, and `b` is comparable by identity, `a` is still not
-necessarily the same type as `b` since the `#==` operator can
-coerce objects for comparison.
-
-### Examples
-
-```ruby
-# bad
-expect(foo).to eql(1)
-expect(foo).to eql(1.0)
-expect(foo).to eql(true)
-expect(foo).to eql(false)
-expect(foo).to eql(:bar)
-expect(foo).to eql(nil)
-
-# good
-expect(foo).to be(1)
-expect(foo).to be(1.0)
-expect(foo).to be(true)
-expect(foo).to be(false)
-expect(foo).to be(:bar)
-expect(foo).to be(nil)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeEql)
-
-## RSpec/BeforeAfterAll
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that before/after(:all) isn't being used.
-
-### Examples
-
-```ruby
-# bad
-#
-# Faster but risk of state leaking between examples
-#
-describe MyClass do
-  before(:all) { Widget.create }
-  after(:all) { Widget.delete_all }
-end
-
-# good
-#
-# Slower but examples are properly isolated
-#
-describe MyClass do
-  before(:each) { Widget.create }
-  after(:each) { Widget.delete_all }
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Exclude | `spec/spec_helper.rb`, `spec/rails_helper.rb`, `spec/support/**/*.rb` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/BeforeAfterAll)
-
-## RSpec/ContextMethod
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-`context` should not be used for specifying methods.
-
-### Examples
-
-```ruby
-# bad
-context '#foo_bar' do
-  # ...
-end
-
-context '.foo_bar' do
-  # ...
-end
-
-# good
-describe '#foo_bar' do
-  # ...
-end
-
-describe '.foo_bar' do
-  # ...
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextMethod)
-
-## RSpec/ContextWording
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that `context` docstring starts with an allowed prefix.
-
-The default list of prefixes is minimal. Users are encouraged to tailor
-the configuration to meet project needs. Other acceptable prefixes may
-include `if`, `unless`, `for`, `before`, `after`, or `during`.
-
-### Examples
-
-#### `Prefixes` configuration
-
-```ruby
-# .rubocop.yml
-# RSpec/ContextWording:
-#   Prefixes:
-#     - when
-#     - with
-#     - without
-#     - if
-#     - unless
-#     - for
-```
-```ruby
-# bad
-context 'the display name not present' do
-  # ...
-end
-
-# good
-context 'when the display name is not present' do
-  # ...
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Prefixes | `when`, `with`, `without` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ContextWording)
-
-## RSpec/DescribeClass
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that the first argument to the top level describe is a constant.
-
-### Examples
-
-```ruby
-# bad
-describe 'Do something' do
-end
-
-# good
-describe TestedClass do
-end
-
-describe "A feature example", type: :feature do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeClass)
-
-## RSpec/DescribeMethod
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that the second argument to `describe` specifies a method.
-
-### Examples
-
-```ruby
-# bad
-describe MyClass, 'do something' do
-end
-
-# good
-describe MyClass, '#my_instance_method' do
-end
-
-describe MyClass, '.my_class_method' do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeMethod)
-
-## RSpec/DescribeSymbol
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Avoid describing symbols.
-
-### Examples
-
-```ruby
-# bad
-describe :my_method do
-  # ...
-end
-
-# good
-describe '#my_method' do
-  # ...
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribeSymbol)
-
-## RSpec/DescribedClass
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks that tests use `described_class`.
-
-If the first argument of describe is a class, the class is exposed to
-each example via described_class.
-
-This cop can be configured using the `EnforcedStyle` and `SkipBlocks`
-options.
-
-There's a known caveat with rspec-rails's `controller` helper that
-runs its block in a different context, and `described_class` is not
-available to it. `SkipBlocks` option excludes detection in all
-non-RSpec related blocks.
-
-To narrow down this setting to only a specific directory, it is
-possible to use an overriding configuration file local to that
-directory.
-
-### Examples
-
-#### `EnforcedStyle: described_class`
-
-```ruby
-# bad
-describe MyClass do
-  subject { MyClass.do_something }
-end
-
-# good
-describe MyClass do
-  subject { described_class.do_something }
-end
-```
-#### `EnforcedStyle: explicit`
-
-```ruby
-# bad
-describe MyClass do
-  subject { described_class.do_something }
-end
-
-# good
-describe MyClass do
-  subject { MyClass.do_something }
-end
-```
-#### `SkipBlocks: true`
-
-```ruby
-# spec/controllers/.rubocop.yml
-# RSpec/DescribedClass:
-#   SkipBlocks: true
-
-# acceptable
-describe MyConcern do
-  controller(ApplicationController) do
-    include MyConcern
-  end
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-SkipBlocks | `false` | Boolean
-EnforcedStyle | `described_class` | `described_class`, `explicit`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClass)
-
-## RSpec/DescribedClassModuleWrapping
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | No
-
-Avoid opening modules and defining specs within them.
-
-### Examples
-
-```ruby
-# bad
-module MyModule
-  RSpec.describe MyClass do
-    # ...
-  end
-end
-
-# good
-RSpec.describe MyModule::MyClass do
-  # ...
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/DescribedClassModuleWrapping)
-
-## RSpec/Dialect
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | Yes
-
-This cop enforces custom RSpec dialects.
-
-A dialect can be based on the following RSpec methods:
-
-- describe, context, feature, example_group
-- xdescribe, xcontext, xfeature
-- fdescribe, fcontext, ffeature
-- shared_examples, shared_examples_for, shared_context
-- it, specify, example, scenario, its
-- fit, fspecify, fexample, fscenario, focus
-- xit, xspecify, xexample, xscenario, skip
-- pending
-- prepend_before, before, append_before,
-- around
-- prepend_after, after, append_after
-- let, let!
-- subject, subject!
-- expect, is_expected, expect_any_instance_of
-
-By default all of the RSpec methods and aliases are allowed. By setting
-a config like:
-
-  RSpec/Dialect:
-    PreferredMethods:
-      context: describe
-
-You can expect the following behavior:
-
-### Examples
-
-```ruby
-# bad
-context 'display name presence' do
-  # ...
-end
-
-# good
-describe 'display name presence' do
-  # ...
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-PreferredMethods | `{}` | 
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Dialect)
-
-## RSpec/EmptyExampleGroup
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks if an example group does not include any tests.
-
-This cop is configurable using the `CustomIncludeMethods` option
-
-### Examples
-
-#### usage
-
-```ruby
-# bad
-describe Bacon do
-  let(:bacon)      { Bacon.new(chunkiness) }
-  let(:chunkiness) { false                 }
-
-  context 'extra chunky' do   # flagged by rubocop
-    let(:chunkiness) { true }
-  end
-
-  it 'is chunky' do
-    expect(bacon.chunky?).to be_truthy
-  end
-end
-
-# good
-describe Bacon do
-  let(:bacon)      { Bacon.new(chunkiness) }
-  let(:chunkiness) { false                 }
-
-  it 'is chunky' do
-    expect(bacon.chunky?).to be_truthy
-  end
-end
-```
-#### configuration
-
-```ruby
-# .rubocop.yml
-# RSpec/EmptyExampleGroup:
-#   CustomIncludeMethods:
-#   - include_tests
-
-# spec_helper.rb
-RSpec.configure do |config|
-  config.alias_it_behaves_like_to(:include_tests)
-end
-
-# bacon_spec.rb
-describe Bacon do
-  let(:bacon)      { Bacon.new(chunkiness) }
-  let(:chunkiness) { false                 }
-
-  context 'extra chunky' do   # not flagged by rubocop
-    let(:chunkiness) { true }
-
-    include_tests 'shared tests'
-  end
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-CustomIncludeMethods | `[]` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyExampleGroup)
-
-## RSpec/EmptyLineAfterExample
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if there is an empty line after example blocks.
-
-### Examples
-
-```ruby
-# bad
-RSpec.describe Foo do
-  it 'does this' do
-  end
-  it 'does that' do
-  end
-end
-
-# good
-RSpec.describe Foo do
-  it 'does this' do
-  end
-
-  it 'does that' do
-  end
-end
-
-# fair - it's ok to have non-separated one-liners
-RSpec.describe Foo do
-  it { one }
-  it { two }
-end
-```
-#### with AllowConsecutiveOneLiners configuration
-
-```ruby
-# rubocop.yml
-# RSpec/EmptyLineAfterExample:
-#   AllowConsecutiveOneLiners: false
-
-# bad
-RSpec.describe Foo do
-  it { one }
-  it { two }
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-AllowConsecutiveOneLiners | `true` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExample)
-
-## RSpec/EmptyLineAfterExampleGroup
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if there is an empty line after example group blocks.
-
-### Examples
-
-```ruby
-# bad
-RSpec.describe Foo do
-  describe '#bar' do
-  end
-  describe '#baz' do
-  end
-end
-
-# good
-RSpec.describe Foo do
-  describe '#bar' do
-  end
-
-  describe '#baz' do
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterExampleGroup)
-
-## RSpec/EmptyLineAfterFinalLet
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if there is an empty line after the last let block.
-
-### Examples
-
-```ruby
-# bad
-let(:foo) { bar }
-let(:something) { other }
-it { does_something }
-
-# good
-let(:foo) { bar }
-let(:something) { other }
-
-it { does_something }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterFinalLet)
-
-## RSpec/EmptyLineAfterHook
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if there is an empty line after hook blocks.
-
-### Examples
-
-```ruby
-# bad
-before { do_something }
-it { does_something }
-
-# bad
-after { do_something }
-it { does_something }
-
-# bad
-around { |test| test.run }
-it { does_something }
-
-# good
-before { do_something }
-
-it { does_something }
-
-# good
-after { do_something }
-
-it { does_something }
-
-# good
-around { |test| test.run }
-
-it { does_something }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterHook)
-
-## RSpec/EmptyLineAfterSubject
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if there is an empty line after subject block.
-
-### Examples
-
-```ruby
-# bad
-subject(:obj) { described_class }
-let(:foo) { bar }
-
-# good
-subject(:obj) { described_class }
-
-let(:foo) { bar }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/EmptyLineAfterSubject)
-
-## RSpec/ExampleLength
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for long examples.
-
-A long example is usually more difficult to understand. Consider
-extracting out some behaviour, e.g. with a `let` block, or a helper
-method.
-
-### Examples
-
-```ruby
-# bad
-it do
-  service = described_class.new
-  more_setup
-  more_setup
-  result = service.call
-  expect(result).to be(true)
-end
-
-# good
-it do
-  service = described_class.new
-  result = service.call
-  expect(result).to be(true)
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Max | `5` | Integer
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleLength)
-
-## RSpec/ExampleWithoutDescription
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for examples without a description.
-
-RSpec allows for auto-generated example descriptions when there is no
-description provided or the description is an empty one.
-
-This cop removes empty descriptions.
-It also defines whether auto-generated description is allowed, based
-on the configured style.
-
-This cop can be configured using the `EnforcedStyle` option
-
-### Examples
-
-#### `EnforcedStyle: always_allow`
-
-```ruby
-# bad
-it('') { is_expected.to be_good }
-it '' do
-  result = service.call
-  expect(result).to be(true)
-end
-
-# good
-it { is_expected.to be_good }
-it do
-  result = service.call
-  expect(result).to be(true)
-end
-```
-#### `EnforcedStyle: single_line_only`
-
-```ruby
-# bad
-it('') { is_expected.to be_good }
-it do
-  result = service.call
-  expect(result).to be(true)
-end
-
-# good
-it { is_expected.to be_good }
-```
-#### `EnforcedStyle: disallow`
-
-```ruby
-# bad
-it { is_expected.to be_good }
-it do
-  result = service.call
-  expect(result).to be(true)
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `always_allow` | `always_allow`, `single_line_only`, `disallow`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWithoutDescription)
-
-## RSpec/ExampleWording
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for common mistakes in example descriptions.
-
-This cop will correct docstrings that begin with 'should' and 'it'.
-
-The autocorrect is experimental - use with care! It can be configured
-with CustomTransform (e.g. have => has) and IgnoredWords (e.g. only).
-
-### Examples
-
-```ruby
-# bad
-it 'should find nothing' do
-end
-
-# good
-it 'finds nothing' do
-end
-```
-```ruby
-# bad
-it 'it does things' do
-end
-
-# good
-it 'does things' do
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-CustomTransform | `{"be"=>"is", "BE"=>"IS", "have"=>"has", "HAVE"=>"HAS"}` | 
-IgnoredWords | `[]` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExampleWording)
-
-## RSpec/ExpectActual
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for `expect(...)` calls containing literal values.
-
-### Examples
-
-```ruby
-# bad
-expect(5).to eq(price)
-expect(/foo/).to eq(pattern)
-expect("John").to eq(name)
-
-# good
-expect(price).to eq(5)
-expect(pattern).to eq(/foo/)
-expect(name).to eq("John")
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Exclude | `spec/routing/**/*` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectActual)
-
-## RSpec/ExpectChange
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for consistent style of change matcher.
-
-Enforces either passing object and attribute as arguments to the matcher
-or passing a block that reads the attribute value.
-
-This cop can be configured using the `EnforcedStyle` option.
-
-### Examples
-
-#### `EnforcedStyle: block`
-
-```ruby
-# bad
-expect { run }.to change(Foo, :bar)
-
-# good
-expect { run }.to change { Foo.bar }
-```
-#### `EnforcedStyle: method_call`
-
-```ruby
-# bad
-expect { run }.to change { Foo.bar }
-expect { run }.to change { foo.baz }
-
-# good
-expect { run }.to change(Foo, :bar)
-expect { run }.to change(foo, :baz)
-# also good when there are arguments or chained method calls
-expect { run }.to change { Foo.bar(:count) }
-expect { run }.to change { user.reload.name }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `method_call` | `method_call`, `block`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectChange)
-
-## RSpec/ExpectInHook
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Do not use `expect` in hooks such as `before`.
-
-### Examples
-
-```ruby
-# bad
-before do
-  expect(something).to eq 'foo'
-end
-
-# bad
-after do
-  expect_any_instance_of(Something).to receive(:foo)
-end
-
-# good
-it do
-  expect(something).to eq 'foo'
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectInHook)
-
-## RSpec/ExpectOutput
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for opportunities to use `expect { ... }.to output`.
-
-### Examples
-
-```ruby
-# bad
-$stdout = StringIO.new
-my_app.print_report
-$stdout = STDOUT
-expect($stdout.string).to eq('Hello World')
-
-# good
-expect { my_app.print_report }.to output('Hello World').to_stdout
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ExpectOutput)
-
-## RSpec/FilePath
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that spec file paths are consistent with the test subject.
-
-Checks the path of the spec file and enforces that it reflects the
-described class/module and its optionally called out method.
-
-With the configuration option `IgnoreMethods` the called out method will
-be ignored when determining the enforced path.
-
-With the configuration option `CustomTransform` modules or classes can
-be specified that should not as usual be transformed from CamelCase to
-snake_case (e.g. 'RuboCop' => 'rubocop' ).
-
-### Examples
-
-```ruby
-# bad
-whatever_spec.rb         # describe MyClass
-
-# bad
-my_class_spec.rb         # describe MyClass, '#method'
-
-# good
-my_class_spec.rb         # describe MyClass
-
-# good
-my_class_method_spec.rb  # describe MyClass, '#method'
-
-# good
-my_class/method_spec.rb  # describe MyClass, '#method'
-```
-#### when configuration is `IgnoreMethods: true`
-
-```ruby
-# bad
-whatever_spec.rb         # describe MyClass
-
-# good
-my_class_spec.rb         # describe MyClass
-
-# good
-my_class_spec.rb         # describe MyClass, '#method'
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-CustomTransform | `{"RuboCop"=>"rubocop", "RSpec"=>"rspec"}` | 
-IgnoreMethods | `false` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FilePath](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/FilePath)
-
-## RSpec/Focus
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks if examples are focused.
-
-### Examples
-
-```ruby
-# bad
-describe MyClass, focus: true do
-end
-
-describe MyClass, :focus do
-end
-
-fdescribe MyClass do
-end
-
-# good
-describe MyClass do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Focus)
-
-## RSpec/HookArgument
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks the arguments passed to `before`, `around`, and `after`.
-
-This cop checks for consistent style when specifying RSpec
-hooks which run for each example. There are three supported
-styles: "implicit", "each", and "example." All styles have
-the same behavior.
-
-### Examples
-
-#### when configuration is `EnforcedStyle: implicit`
-
-```ruby
-# bad
-before(:each) do
-  # ...
-end
-
-# bad
-before(:example) do
-  # ...
-end
-
-# good
-before do
-  # ...
-end
-```
-#### when configuration is `EnforcedStyle: each`
-
-```ruby
-# bad
-before(:example) do
-  # ...
-end
-
-# good
-before do
-  # ...
-end
-
-# good
-before(:each) do
-  # ...
-end
-```
-#### when configuration is `EnforcedStyle: example`
-
-```ruby
-# bad
-before(:each) do
-  # ...
-end
-
-# bad
-before do
-  # ...
-end
-
-# good
-before(:example) do
-  # ...
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `implicit` | `implicit`, `each`, `example`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HookArgument)
-
-## RSpec/HooksBeforeExamples
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for before/around/after hooks that come after an example.
-
-### Examples
-
-```ruby
-# Bad
-
-it 'checks what foo does' do
-  expect(foo).to be
-end
-
-before { prepare }
-after { clean_up }
-
-# Good
-before { prepare }
-after { clean_up }
-
-it 'checks what foo does' do
-  expect(foo).to be
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/HooksBeforeExamples)
-
-## RSpec/ImplicitBlockExpectation
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that implicit block expectation syntax is not used.
-
-Prefer using explicit block expectations.
-
-### Examples
-
-```ruby
-# bad
-subject { -> { do_something } }
-it { is_expected.to change(something).to(new_value) }
-
-# good
-it 'changes something to a new value' do
-  expect { do_something }.to change(something).to(new_value)
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitBlockExpectation)
-
-## RSpec/ImplicitExpect
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Check that a consistent implicit expectation style is used.
-
-This cop can be configured using the `EnforcedStyle` option
-and supports the `--auto-gen-config` flag.
-
-### Examples
-
-#### `EnforcedStyle: is_expected`
-
-```ruby
-# bad
-it { should be_truthy }
-
-# good
-it { is_expected.to be_truthy }
-```
-#### `EnforcedStyle: should`
-
-```ruby
-# bad
-it { is_expected.to be_truthy }
-
-# good
-it { should be_truthy }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `is_expected` | `is_expected`, `should`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitExpect)
-
-## RSpec/ImplicitSubject
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for usage of implicit subject (`is_expected` / `should`).
-
-This cop can be configured using the `EnforcedStyle` option
-
-### Examples
-
-#### `EnforcedStyle: single_line_only`
-
-```ruby
-# bad
-it do
-  is_expected.to be_truthy
-end
-
-# good
-it { is_expected.to be_truthy }
-it do
-  expect(subject).to be_truthy
-end
-```
-#### `EnforcedStyle: disallow`
-
-```ruby
-# bad
-it { is_expected.to be_truthy }
-
-# good
-it { expect(subject).to be_truthy }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `single_line_only` | `single_line_only`, `single_statement_only`, `disallow`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ImplicitSubject)
-
-## RSpec/InstanceSpy
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for `instance_double` used with `have_received`.
-
-### Examples
-
-```ruby
-# bad
-it do
-  foo = instance_double(Foo).as_null_object
-  expect(foo).to have_received(:bar)
-end
-
-# good
-it do
-  foo = instance_spy(Foo)
-  expect(foo).to have_received(:bar)
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceSpy)
-
-## RSpec/InstanceVariable
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for instance variable usage in specs.
-
-This cop can be configured with the option `AssignmentOnly` which
-will configure the cop to only register offenses on instance
-variable usage if the instance variable is also assigned within
-the spec
-
-### Examples
-
-```ruby
-# bad
-describe MyClass do
-  before { @foo = [] }
-  it { expect(@foo).to be_empty }
-end
-
-# good
-describe MyClass do
-  let(:foo) { [] }
-  it { expect(foo).to be_empty }
-end
-```
-#### with AssignmentOnly configuration
-
-```ruby
-# rubocop.yml
-# RSpec/InstanceVariable:
-#   AssignmentOnly: false
-
-# bad
-describe MyClass do
-  before { @foo = [] }
-  it { expect(@foo).to be_empty }
-end
-
-# allowed
-describe MyClass do
-  it { expect(@foo).to be_empty }
-end
-
-# good
-describe MyClass do
-  let(:foo) { [] }
-  it { expect(foo).to be_empty }
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-AssignmentOnly | `false` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InstanceVariable)
-
-## RSpec/InvalidPredicateMatcher
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks invalid usage for predicate matcher.
-
-Predicate matcher does not need a question.
-This cop checks an unnecessary question in predicate matcher.
-
-### Examples
-
-```ruby
-# bad
-expect(foo).to be_something?
-
-# good
-expect(foo).to be_something
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InvalidPredicateMatcher](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/InvalidPredicateMatcher)
-
-## RSpec/ItBehavesLike
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks that only one `it_behaves_like` style is used.
-
-### Examples
-
-#### when configuration is `EnforcedStyle: it_behaves_like`
-
-```ruby
-# bad
-it_should_behave_like 'a foo'
-
-# good
-it_behaves_like 'a foo'
-```
-#### when configuration is `EnforcedStyle: it_should_behave_like`
-
-```ruby
-# bad
-it_behaves_like 'a foo'
-
-# good
-it_should_behave_like 'a foo'
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `it_behaves_like` | `it_behaves_like`, `it_should_behave_like`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ItBehavesLike)
-
-## RSpec/IteratedExpectation
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that `all` matcher is used instead of iterating over an array.
-
-### Examples
-
-```ruby
-# bad
-it 'validates users' do
-  [user1, user2, user3].each { |user| expect(user).to be_valid }
-end
-
-# good
-it 'validates users' do
-  expect([user1, user2, user3]).to all(be_valid)
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/IteratedExpectation)
-
-## RSpec/LeadingSubject
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Enforce that subject is the first definition in the test.
-
-### Examples
-
-```ruby
-# bad
-  let(:params) { blah }
-  subject { described_class.new(params) }
-
-  before { do_something }
-  subject { described_class.new(params) }
-
-  it { expect_something }
-  subject { described_class.new(params) }
-  it { expect_something_else }
-
-# good
-  subject { described_class.new(params) }
-  let(:params) { blah }
-
-# good
-  subject { described_class.new(params) }
-  before { do_something }
-
-# good
-  subject { described_class.new(params) }
-  it { expect_something }
-  it { expect_something_else }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeadingSubject)
-
-## RSpec/LeakyConstantDeclaration
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that no class, module, or constant is declared.
-
-Constants, including classes and modules, when declared in a block
-scope, are defined in global namespace, and leak between examples.
-
-If several examples may define a `DummyClass`, instead of being a
-blank slate class as it will be in the first example, subsequent
-examples will be reopening it and modifying its behaviour in
-unpredictable ways.
-Even worse when a class that exists in the codebase is reopened.
-
-Anonymous classes are fine, since they don't result in global
-namespace name clashes.
-
-### Examples
-
-#### Constants leak between examples
-
-```ruby
-# bad
-describe SomeClass do
-  OtherClass = Struct.new
-  CONSTANT_HERE = 'I leak into global namespace'
-end
-
-# good
-describe SomeClass do
-  before do
-    stub_const('OtherClass', Struct.new)
-    stub_const('CONSTANT_HERE', 'I only exist during this example')
-  end
-end
-```
-```ruby
-# bad
-describe SomeClass do
-  class FooClass < described_class
-    def double_that
-      some_base_method * 2
-    end
-  end
-
-  it { expect(FooClass.new.double_that).to eq(4) }
-end
-
-# good - anonymous class, no constant needs to be defined
-describe SomeClass do
-  let(:foo_class) do
-    Class.new(described_class) do
-      def double_that
-        some_base_method * 2
-      end
-    end
-  end
-
-  it { expect(foo_class.new.double_that).to eq(4) }
-end
-
-# good - constant is stubbed
-describe SomeClass do
-  before do
-    foo_class = Class.new(described_class) do
-                  def do_something
-                  end
-                end
-    stub_const('FooClass', foo_class)
-  end
-
-  it { expect(FooClass.new.double_that).to eq(4) }
-end
-```
-```ruby
-# bad
-describe SomeClass do
-  module SomeModule
-    class SomeClass
-      def do_something
-      end
-    end
-  end
-end
-
-# good
-describe SomeClass do
-  before do
-    foo_class = Class.new(described_class) do
-                  def do_something
-                  end
-                end
-    stub_const('SomeModule::SomeClass', foo_class)
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LeakyConstantDeclaration)
-
-## RSpec/LetBeforeExamples
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for `let` definitions that come after an example.
-
-### Examples
-
-```ruby
-# Bad
-let(:foo) { bar }
-
-it 'checks what foo does' do
-  expect(foo).to be
-end
-
-let(:some) { other }
-
-it 'checks what some does' do
-  expect(some).to be
-end
-
-# Good
-let(:foo) { bar }
-let(:some) { other }
-
-it 'checks what foo does' do
-  expect(foo).to be
-end
-
-it 'checks what some does' do
-  expect(some).to be
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetBeforeExamples)
-
-## RSpec/LetSetup
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks unreferenced `let!` calls being used for test setup.
-
-### Examples
-
-```ruby
-# Bad
-let!(:my_widget) { create(:widget) }
-
-it 'counts widgets' do
-  expect(Widget.count).to eq(1)
-end
-
-# Good
-it 'counts widgets' do
-  create(:widget)
-  expect(Widget.count).to eq(1)
-end
-
-# Good
-before { create(:widget) }
-
-it 'counts widgets' do
-  expect(Widget.count).to eq(1)
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/LetSetup)
-
-## RSpec/MessageChain
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check that chains of messages are not being stubbed.
-
-### Examples
-
-```ruby
-# bad
-allow(foo).to receive_message_chain(:bar, :baz).and_return(42)
-
-# better
-thing = Thing.new(baz: 42)
-allow(foo).to receive(:bar).and_return(thing)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageChain)
-
-## RSpec/MessageExpectation
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | No
-
-Checks for consistent message expectation style.
-
-This cop can be configured in your configuration using the
-`EnforcedStyle` option and supports `--auto-gen-config`.
-
-### Examples
-
-#### `EnforcedStyle: allow`
-
-```ruby
-# bad
-expect(foo).to receive(:bar)
-
-# good
-allow(foo).to receive(:bar)
-```
-#### `EnforcedStyle: expect`
-
-```ruby
-# bad
-allow(foo).to receive(:bar)
-
-# good
-expect(foo).to receive(:bar)
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `allow` | `allow`, `expect`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageExpectation)
-
-## RSpec/MessageSpies
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that message expectations are set using spies.
-
-This cop can be configured in your configuration using the
-`EnforcedStyle` option and supports `--auto-gen-config`.
-
-### Examples
-
-#### `EnforcedStyle: have_received`
-
-```ruby
-# bad
-expect(foo).to receive(:bar)
-
-# good
-expect(foo).to have_received(:bar)
-```
-#### `EnforcedStyle: receive`
-
-```ruby
-# bad
-expect(foo).to have_received(:bar)
-
-# good
-expect(foo).to receive(:bar)
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `have_received` | `have_received`, `receive`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MessageSpies)
-
-## RSpec/MissingExampleGroupArgument
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks that the first argument to an example group is not empty.
-
-### Examples
-
-```ruby
-# bad
-describe do
-end
-
-RSpec.describe do
-end
-
-# good
-describe TestedClass do
-end
-
-describe "A feature example" do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MissingExampleGroupArgument)
-
-## RSpec/MultipleDescribes
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for multiple top level describes.
-
-Multiple descriptions for the same class or module should either
-be nested or separated into different test files.
-
-### Examples
-
-```ruby
-# bad
-describe MyClass, '.do_something' do
-end
-describe MyClass, '.do_something_else' do
-end
-
-# good
-describe MyClass do
-  describe '.do_something' do
-  end
-  describe '.do_something_else' do
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleDescribes)
-
-## RSpec/MultipleExpectations
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks if examples contain too many `expect` calls.
-
-This cop is configurable using the `Max` option
-and works with `--auto-gen-config`.
-
-### Examples
-
-```ruby
-# bad
-describe UserCreator do
-  it 'builds a user' do
-    expect(user.name).to eq("John")
-    expect(user.age).to eq(22)
-  end
-end
-
-# good
-describe UserCreator do
-  it 'sets the users name' do
-    expect(user.name).to eq("John")
-  end
-
-  it 'sets the users age' do
-    expect(user.age).to eq(22)
-  end
-end
-```
-#### configuration
-
-```ruby
-# .rubocop.yml
-# RSpec/MultipleExpectations:
-#   Max: 2
-
-# not flagged by rubocop
-describe UserCreator do
-  it 'builds a user' do
-    expect(user.name).to eq("John")
-    expect(user.age).to eq(22)
-  end
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Max | `1` | Integer
-AggregateFailuresByDefault | `false` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleExpectations)
-
-## RSpec/MultipleSubjects
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks if an example group defines `subject` multiple times.
-
-The autocorrect behavior for this cop depends on the type of
-duplication:
-
-  - If multiple named subjects are defined then this probably indicates
-    that the overwritten subjects (all subjects except the last
-    definition) are effectively being used to define helpers. In this
-    case they are replaced with `let`.
-
-  - If multiple unnamed subjects are defined though then this can *only*
-    be dead code and we remove the overwritten subject definitions.
-
-  - If subjects are defined with `subject!` then we don't autocorrect.
-    This is enough of an edge case that people can just move this to
-    a `before` hook on their own
-
-### Examples
-
-```ruby
-# bad
-describe Foo do
-  subject(:user) { User.new }
-  subject(:post) { Post.new }
-end
-
-# good
-describe Foo do
-  let(:user) { User.new }
-  subject(:post) { Post.new }
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/MultipleSubjects)
-
-## RSpec/NamedSubject
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for explicitly referenced test subjects.
-
-RSpec lets you declare an "implicit subject" using `subject { ... }`
-which allows for tests like `it { should be_valid }`. If you need to
-reference your test subject you should explicitly name it using
-`subject(:your_subject_name) { ... }`. Your test subjects should be
-the most important object in your tests so they deserve a descriptive
-name.
-
-This cop can be configured in your configuration using the
-`IgnoreSharedExamples` which will not report offenses for implicit
-subjects in shared example groups.
-
-### Examples
-
-```ruby
-# bad
-RSpec.describe User do
-  subject { described_class.new }
-
-  it 'is valid' do
-    expect(subject.valid?).to be(true)
-  end
-end
-
-# good
-RSpec.describe Foo do
-  subject(:user) { described_class.new }
-
-  it 'is valid' do
-    expect(user.valid?).to be(true)
-  end
-end
-
-# also good
-RSpec.describe Foo do
-  subject(:user) { described_class.new }
-
-  it { should be_valid }
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-IgnoreSharedExamples | `true` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NamedSubject)
-
-## RSpec/NestedGroups
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for nested example groups.
-
-This cop is configurable using the `Max` option
-and supports `--auto-gen-config
-
-### Examples
-
-```ruby
-# bad
-context 'when using some feature' do
-  let(:some)    { :various }
-  let(:feature) { :setup   }
-
-  context 'when user is signed in' do  # flagged by rubocop
-    let(:user) do
-      UserCreate.call(user_attributes)
-    end
-
-    let(:user_attributes) do
-      {
-        name: 'John',
-        age:  22,
-        role: role
-      }
-    end
-
-    context 'when user is an admin' do # flagged by rubocop
-      let(:role) { 'admin' }
-
-      it 'blah blah'
-      it 'yada yada'
-    end
-  end
-end
-
-# better
-context 'using some feature as an admin' do
-  let(:some)    { :various }
-  let(:feature) { :setup   }
-
-  let(:user) do
-    UserCreate.call(
-      name: 'John',
-      age:  22,
-      role: 'admin'
-    )
-  end
-
-  it 'blah blah'
-  it 'yada yada'
-end
-```
-#### configuration
-
-```ruby
-# .rubocop.yml
-# RSpec/NestedGroups:
-#   Max: 2
-
-context 'when using some feature' do
-  let(:some)    { :various }
-  let(:feature) { :setup   }
-
-  context 'when user is signed in' do
-    let(:user) do
-      UserCreate.call(user_attributes)
-    end
-
-    let(:user_attributes) do
-      {
-        name: 'John',
-        age:  22,
-        role: role
-      }
-    end
-
-    context 'when user is an admin' do # flagged by rubocop
-      let(:role) { 'admin' }
-
-      it 'blah blah'
-      it 'yada yada'
-    end
-  end
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Max | `3` | Integer
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NestedGroups)
-
-## RSpec/NotToNot
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for consistent method usage for negating expectations.
-
-### Examples
-
-```ruby
-# bad
-it '...' do
-  expect(false).to_not be_true
-end
-
-# good
-it '...' do
-  expect(false).not_to be_true
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `not_to` | `not_to`, `to_not`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/NotToNot)
-
-## RSpec/OverwritingSetup
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks if there is a let/subject that overwrites an existing one.
-
-### Examples
-
-```ruby
-# bad
-let(:foo) { bar }
-let(:foo) { baz }
-
-subject(:foo) { bar }
-let(:foo) { baz }
-
-let(:foo) { bar }
-let!(:foo) { baz }
-
-# good
-subject(:test) { something }
-let(:foo) { bar }
-let(:baz) { baz }
-let!(:other) { other }
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/OverwritingSetup)
-
-## RSpec/Pending
-
-Enabled by default | Supports autocorrection
---- | ---
-Disabled | No
-
-Checks for any pending or skipped examples.
-
-### Examples
-
-```ruby
-# bad
-describe MyClass do
-  it "should be true"
-end
-
-describe MyClass do
-  it "should be true", skip: true do
-    expect(1).to eq(2)
-  end
-end
-
-describe MyClass do
-  it "should be true" do
-    pending
-  end
-end
-
-describe MyClass do
-  xit "should be true" do
-  end
-end
-
-# good
-describe MyClass do
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Pending)
-
-## RSpec/PredicateMatcher
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Prefer using predicate matcher over using predicate method directly.
-
-RSpec defines magic matchers for predicate methods.
-This cop recommends to use the predicate matcher instead of using
-predicate method directly.
-
-### Examples
-
-#### Strict: true, EnforcedStyle: inflected (default)
-
-```ruby
-# bad
-expect(foo.something?).to be_truthy
-
-# good
-expect(foo).to be_something
-
-# also good - It checks "true" strictly.
-expect(foo).to be(true)
-```
-#### Strict: false, EnforcedStyle: inflected
-
-```ruby
-# bad
-expect(foo.something?).to be_truthy
-expect(foo).to be(true)
-
-# good
-expect(foo).to be_something
-```
-#### Strict: true, EnforcedStyle: explicit
-
-```ruby
-# bad
-expect(foo).to be_something
-
-# good - the above code is rewritten to it by this cop
-expect(foo.something?).to be(true)
-```
-#### Strict: false, EnforcedStyle: explicit
-
-```ruby
-# bad
-expect(foo).to be_something
-
-# good - the above code is rewritten to it by this cop
-expect(foo.something?).to be_truthy
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-Strict | `true` | Boolean
-EnforcedStyle | `inflected` | `inflected`, `explicit`
-AllowedExplicitMatchers | `[]` | Array
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/PredicateMatcher)
-
-## RSpec/ReceiveCounts
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Check for `once` and `twice` receive counts matchers usage.
-
-### Examples
-
-```ruby
-# bad
-expect(foo).to receive(:bar).exactly(1).times
-expect(foo).to receive(:bar).exactly(2).times
-expect(foo).to receive(:bar).at_least(1).times
-expect(foo).to receive(:bar).at_least(2).times
-expect(foo).to receive(:bar).at_most(1).times
-expect(foo).to receive(:bar).at_most(2).times
-
-# good
-expect(foo).to receive(:bar).once
-expect(foo).to receive(:bar).twice
-expect(foo).to receive(:bar).at_least(:once)
-expect(foo).to receive(:bar).at_least(:twice)
-expect(foo).to receive(:bar).at_most(:once)
-expect(foo).to receive(:bar).at_most(:twice).times
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveCounts)
-
-## RSpec/ReceiveNever
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Prefer `not_to receive(...)` over `receive(...).never`.
-
-### Examples
-
-```ruby
-# bad
-expect(foo).to receive(:bar).never
-
-# good
-expect(foo).not_to receive(:bar)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReceiveNever)
-
-## RSpec/RepeatedDescription
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check for repeated description strings in example groups.
-
-### Examples
-
-```ruby
-# bad
-RSpec.describe User do
-  it 'is valid' do
-    # ...
-  end
-
-  it 'is valid' do
-    # ...
-  end
-end
-
-# good
-RSpec.describe User do
-  it 'is valid when first and last name are present' do
-    # ...
-  end
-
-  it 'is valid when last name only is present' do
-    # ...
-  end
-end
-
-# good
-RSpec.describe User do
-  it 'is valid' do
-    # ...
-  end
-
-  it 'is valid', :flag do
-    # ...
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedDescription)
-
-## RSpec/RepeatedExample
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check for repeated examples within example groups.
-
-### Examples
-
-```ruby
-it 'is valid' do
-  expect(user).to be_valid
-end
-
-it 'validates the user' do
-  expect(user).to be_valid
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExample)
-
-## RSpec/RepeatedExampleGroupBody
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check for repeated describe and context block body.
-
-### Examples
-
-```ruby
-# bad
-describe 'cool feature x' do
-  it { cool_predicate }
-end
-
-describe 'cool feature y' do
-  it { cool_predicate }
-end
-
-# good
-describe 'cool feature' do
-  it { cool_predicate }
-end
-
-describe 'another cool feature' do
-  it { another_predicate }
-end
-
-# good
-context 'when case x', :tag do
-  it { cool_predicate }
-end
-
-context 'when case y' do
-  it { cool_predicate }
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupBody)
-
-## RSpec/RepeatedExampleGroupDescription
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Check for repeated example group descriptions.
-
-### Examples
-
-```ruby
-# bad
-describe 'cool feature' do
-  # example group
-end
-
-describe 'cool feature' do
-  # example group
-end
-
-# bad
-context 'when case x' do
-  # example group
-end
-
-describe 'when case x' do
-  # example group
-end
-
-# good
-describe 'cool feature' do
-  # example group
-end
-
-describe 'another cool feature' do
-  # example group
-end
-
-# good
-context 'when case x' do
-  # example group
-end
-
-context 'when another case' do
-  # example group
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/RepeatedExampleGroupDescription)
-
-## RSpec/ReturnFromStub
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for consistent style of stub's return setting.
-
-Enforces either `and_return` or block-style return in the cases
-where the returned value is constant. Ignores dynamic returned values
-are the result would be different
-
-This cop can be configured using the `EnforcedStyle` option
-
-### Examples
-
-#### `EnforcedStyle: block`
-
-```ruby
-# bad
-allow(Foo).to receive(:bar).and_return("baz")
-expect(Foo).to receive(:bar).and_return("baz")
-
-# good
-allow(Foo).to receive(:bar) { "baz" }
-expect(Foo).to receive(:bar) { "baz" }
-# also good as the returned value is dynamic
-allow(Foo).to receive(:bar).and_return(bar.baz)
-```
-#### `EnforcedStyle: and_return`
-
-```ruby
-# bad
-allow(Foo).to receive(:bar) { "baz" }
-expect(Foo).to receive(:bar) { "baz" }
-
-# good
-allow(Foo).to receive(:bar).and_return("baz")
-expect(Foo).to receive(:bar).and_return("baz")
-# also good as the returned value is dynamic
-allow(Foo).to receive(:bar) { bar.baz }
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-EnforcedStyle | `and_return` | `and_return`, `block`
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ReturnFromStub)
-
-## RSpec/ScatteredLet
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for let scattered across the example group.
-
-Group lets together
-
-### Examples
-
-```ruby
-# bad
-describe Foo do
-  let(:foo) { 1 }
-  subject { Foo }
-  let(:bar) { 2 }
-  before { prepare }
-  let!(:baz) { 3 }
-end
-
-# good
-describe Foo do
-  subject { Foo }
-  before { prepare }
-  let(:foo) { 1 }
-  let(:bar) { 2 }
-  let!(:baz) { 3 }
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredLet)
-
-## RSpec/ScatteredSetup
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for setup scattered across multiple hooks in an example group.
-
-Unify `before`, `after`, and `around` hooks when possible.
-
-### Examples
-
-```ruby
-# bad
-describe Foo do
-  before { setup1 }
-  before { setup2 }
-end
-
-# good
-describe Foo do
-  before do
-    setup1
-    setup2
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/ScatteredSetup)
-
-## RSpec/SharedContext
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks for proper shared_context and shared_examples usage.
-
-If there are no examples defined, use shared_context.
-If there is no setup defined, use shared_examples.
-
-### Examples
-
-```ruby
-# bad
-RSpec.shared_context 'only examples here' do
-  it 'does x' do
-  end
-
-  it 'does y' do
-  end
-end
-
-# good
-RSpec.shared_examples 'only examples here' do
-  it 'does x' do
-  end
-
-  it 'does y' do
-  end
-end
-```
-```ruby
-# bad
-RSpec.shared_examples 'only setup here' do
-  subject(:foo) { :bar }
-
-  let(:baz) { :bazz }
-
-  before do
-    something
-  end
-end
-
-# good
-RSpec.shared_context 'only setup here' do
-  subject(:foo) { :bar }
-
-  let(:baz) { :bazz }
-
-  before do
-    something
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedContext)
-
-## RSpec/SharedExamples
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Enforces use of string to titleize shared examples.
-
-### Examples
-
-```ruby
-# bad
-it_behaves_like :foo_bar_baz
-it_should_behave_like :foo_bar_baz
-shared_examples :foo_bar_baz
-shared_examples_for :foo_bar_baz
-include_examples :foo_bar_baz
-
-# good
-it_behaves_like 'foo bar baz'
-it_should_behave_like 'foo bar baz'
-shared_examples 'foo bar baz'
-shared_examples_for 'foo bar baz'
-include_examples 'foo bar baz'
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SharedExamples)
-
-## RSpec/SingleArgumentMessageChain
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-Checks that chains of messages contain more than one element.
-
-### Examples
-
-```ruby
-# bad
-allow(foo).to receive_message_chain(:bar).and_return(42)
-
-# good
-allow(foo).to receive(:bar).and_return(42)
-
-# also good
-allow(foo).to receive(:bar, :baz)
-allow(foo).to receive("bar.baz")
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SingleArgumentMessageChain)
-
-## RSpec/SubjectStub
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for stubbed test subjects.
-
-### Examples
-
-```ruby
-# bad
-describe Foo do
-  subject(:bar) { baz }
-
-  before do
-    allow(bar).to receive(:qux?).and_return(true)
-  end
-end
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/SubjectStub)
-
-## RSpec/UnspecifiedException
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Checks for a specified error in checking raised errors.
-
-Enforces one of an Exception type, a string, or a regular
-expression to match against the exception message as a parameter
-to `raise_error`
-
-### Examples
-
-```ruby
-# bad
-expect {
-  raise StandardError.new('error')
-}.to raise_error
-
-# good
-expect {
-  raise StandardError.new('error')
-}.to raise_error(StandardError)
-
-expect {
-  raise StandardError.new('error')
-}.to raise_error('error')
-
-expect {
-  raise StandardError.new('error')
-}.to raise_error(/err/)
-
-expect { do_something }.not_to raise_error
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/UnspecifiedException)
-
-## RSpec/VerifiedDoubles
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-Prefer using verifying doubles over normal doubles.
-
-### Examples
-
-```ruby
-# bad
-let(:foo) do
-  double(method_name: 'returned value')
-end
-
-# bad
-let(:foo) do
-  double("ClassName", method_name: 'returned value')
-end
-
-# good
-let(:foo) do
-  instance_double("ClassName", method_name: 'returned value')
-end
-```
-
-### Configurable attributes
-
-Name | Default value | Configurable values
---- | --- | ---
-IgnoreNameless | `true` | Boolean
-IgnoreSymbolicNames | `false` | Boolean
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VerifiedDoubles)
-
-## RSpec/VoidExpect
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | No
-
-This cop checks void `expect()`.
-
-### Examples
-
-```ruby
-# bad
-expect(something)
-
-# good
-expect(something).to be(1)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/VoidExpect)
-
-## RSpec/Yield
-
-Enabled by default | Supports autocorrection
---- | ---
-Enabled | Yes
-
-This cop checks for calling a block within a stub.
-
-### Examples
-
-```ruby
-# bad
-allow(foo).to receive(:bar) { |&block| block.call(1) }
-
-# good
-expect(foo).to be(:bar).and_yield(1)
-```
-
-### References
-
-* [https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield](https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Yield)
diff --git a/manual/index.md b/manual/index.md
deleted file mode 100644
index 2937c0cbf..000000000
--- a/manual/index.md
+++ /dev/null
@@ -1,2 +0,0 @@
-RSpec-specific analysis for your projects, as an extension to
-[RuboCop](https://github.com/rubocop-hq/rubocop).
diff --git a/manual/usage.md b/manual/usage.md
deleted file mode 100644
index b9e348e0a..000000000
--- a/manual/usage.md
+++ /dev/null
@@ -1,31 +0,0 @@
-You need to tell RuboCop to load the RSpec extension. There are three
-ways to do this:
-
-### RuboCop configuration file
-
-Put this into your `.rubocop.yml`.
-
-```
-require: rubocop-rspec
-```
-
-Now you can run `rubocop` and it will automatically load the RuboCop RSpec
-cops together with the standard cops.
-
-### Command line
-
-```bash
-rubocop --require rubocop-rspec
-```
-
-### Rake task
-
-```ruby
-RuboCop::RakeTask.new do |task|
-  task.requires << 'rubocop-rspec'
-end
-```
-
-### Code Climate
-
-rubocop-rspec is available on Code Climate as part of the rubocop engine. [Learn More](https://codeclimate.com/changelog/55a433bbe30ba00852000fac).
diff --git a/mkdocs.yml b/mkdocs.yml
deleted file mode 100644
index a22d97854..000000000
--- a/mkdocs.yml
+++ /dev/null
@@ -1,14 +0,0 @@
-site_name: "RSpec-specific analysis for your projects, as an extension to RuboCop."
-repo_url: https://github.com/rubocop-hq/rubocop-rspec
-docs_dir: manual
-pages:
-- Home: index.md
-- Installation: installation.md
-- Usage: usage.md
-- Cops: cops.md
-- Cops Documentation:
-    - RSpec Cops: cops_rspec.md
-    - Rails Cops: cops_rails.md
-    - FactoryBot Cops: cops_factorybot.md
-    - Capybara Cops: cops_capybara.md
-theme: readthedocs
diff --git a/rubocop-rspec.gemspec b/rubocop-rspec.gemspec
index c98ce4a1f..5296dd3e2 100644
--- a/rubocop-rspec.gemspec
+++ b/rubocop-rspec.gemspec
@@ -6,11 +6,11 @@ require 'rubocop/rspec/version'
 Gem::Specification.new do |spec|
   spec.name = 'rubocop-rspec'
   spec.summary = 'Code style checking for RSpec files'
-  spec.description = <<-DESCRIPTION
+  spec.description = <<~DESCRIPTION
     Code style checking for RSpec files.
     A plugin for the RuboCop code style enforcing & linting tool.
   DESCRIPTION
-  spec.homepage = 'https://github.com/rubocop-hq/rubocop-rspec'
+  spec.homepage = 'https://github.com/rubocop/rubocop-rspec'
   spec.authors = ['John Backus', 'Ian MacLeod', 'Nils Gemeinhardt']
   spec.email = [
     'johncbackus@gmail.com',
@@ -21,29 +21,23 @@ Gem::Specification.new do |spec|
 
   spec.version = RuboCop::RSpec::Version::STRING
   spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.3.0'
+  spec.required_ruby_version = '>= 2.7.0'
 
   spec.require_paths = ['lib']
   spec.files = Dir[
     'lib/**/*',
-    'config/default.yml',
+    'config/*',
     '*.md'
   ]
   spec.extra_rdoc_files = ['MIT-LICENSE.md', 'README.md']
 
   spec.metadata = {
-    'changelog_uri' => 'https://github.com/rubocop-hq/rubocop-rspec/blob/master/CHANGELOG.md',
-    'documentation_uri' => 'https://rubocop-rspec.readthedocs.io/'
+    'changelog_uri' => 'https://github.com/rubocop/rubocop-rspec/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://docs.rubocop.org/rubocop-rspec/',
+    'rubygems_mfa_required' => 'true',
+    'default_lint_roller_plugin' => 'RuboCop::RSpec::Plugin'
   }
 
-  spec.add_runtime_dependency 'rubocop', '>= 0.68.1'
-
-  spec.add_development_dependency 'rack'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '>= 3.4'
-  # Workaround for cc-test-reporter with SimpleCov 0.18.
-  # Stop upgrading SimpleCov until the following issue will be resolved.
-  # https://github.com/codeclimate/test-reporter/issues/418
-  spec.add_development_dependency 'simplecov', '< 0.18'
-  spec.add_development_dependency 'yard'
+  spec.add_dependency 'lint_roller', '~> 1.1'
+  spec.add_dependency 'rubocop', '~> 1.72', '>= 1.72.1'
 end
diff --git a/spec/project/changelog_spec.rb b/spec/project/changelog_spec.rb
index 7e06b13a5..198669361 100644
--- a/spec/project/changelog_spec.rb
+++ b/spec/project/changelog_spec.rb
@@ -4,61 +4,51 @@
   subject(:changelog) { SpecHelper::ROOT.join('CHANGELOG.md').read }
 
   it 'has link definitions for all implicit links' do
-    implicit_link_names = changelog.scan(/\[([^\]]+)\]\[\]/).flatten.uniq
-    implicit_link_names.each do |name|
-      expect(changelog).to include("[#{name}]: http")
-    end
-  end
+    entries, contributors =
+      changelog.split("<!-- Contributors (alphabetically) -->\n\n")
 
-  describe 'entry' do
-    subject(:entries) { lines.grep(/^\*/).map(&:chomp) }
+    implicit_link_names = entries.scan(/\[@(.+?)\]/).flatten.uniq
+    expected_links = implicit_link_names.sort_by(&:downcase).map do |name|
+      "[@#{name.downcase}]: https://github.com/#{name}\n"
+    end.join
 
-    let(:lines) { changelog.each_line }
+    expect(contributors).to eq(expected_links)
+  end
 
-    it 'has a whitespace between the * and the body' do
-      expect(entries).to all(match(/^\* \S/))
+  describe 'contributors list' do
+    let(:contributors) do
+      changelog.split("<!-- Contributors (alphabetically) -->\n\n").last
+        .lines
     end
 
-    it 'has a link to the contributors at the end' do
-      expect(entries).to all(match(/\(\[@\S+\]\[\](?:, \[@\S+\]\[\])*\)$/))
+    it 'does not contain duplicates' do
+      expect(contributors.uniq).to eq(contributors)
     end
 
-    describe 'link to related issue on github' do
-      let(:issues) do
-        entries.map do |entry|
-          entry.match(/\[(?<number>[#\d]+)\]\((?<url>[^\)]+)\)/)
-        end.compact
-      end
+    it 'is alphabetically sorted (case insensitive)' do
+      expect(contributors.sort_by(&:downcase)).to eq(contributors)
+    end
+  end
 
-      it 'has an issue number prefixed with #' do
-        issues.each do |issue|
-          expect(issue[:number]).to match(/^#\d+$/)
-        end
-      end
+  describe 'entry' do
+    subject(:entries) { lines.grep(/^-/).map(&:chomp) }
 
-      it 'has a valid URL' do
-        issues.each do |issue|
-          number = issue[:number].gsub(/\D/, '')
-          pattern = %r{^https://github\.com/.+/.+/(?:issues|pull)/#{number}$}
-          expect(issue[:url]).to match(pattern)
-        end
-      end
+    let(:lines) { changelog.each_line }
 
-      it 'has a colon and a whitespace at the end' do
-        entries_including_issue_link = entries.select do |entry|
-          entry.match(/^\*\s*\[/)
-        end
+    it 'has some entries' do
+      expect(entries).not_to be_empty
+    end
 
-        expect(entries_including_issue_link).to all(include('): '))
-      end
+    it 'has a link to the contributors at the end' do
+      expect(entries).to all(match(/\(\[@\S+\](?:, \[@\S+\])*\)$/))
     end
 
     describe 'body' do
       let(:bodies) do
         entries.map do |entry|
           entry
-            .sub(/^\*\s*(?:\[.+?\):\s*)?/, '')
-            .sub(/\s*\([^\)]+\)$/, '')
+            .sub(/^-\s*(?:\[.+?\):\s*)?/, '')
+            .sub(/\s*\([^)]+\)$/, '')
         end
       end
 
@@ -69,7 +59,13 @@
       end
 
       it 'ends with a punctuation' do
-        expect(bodies).to all(match(/[\.\!]$/))
+        expect(bodies).to all(match(/[.!]$/))
+      end
+
+      it 'does not use consecutive whitespaces' do
+        entries.each do |entry|
+          expect(entry).not_to match(/\s{2,}/)
+        end
       end
     end
   end
diff --git a/spec/project/default_config_spec.rb b/spec/project/default_config_spec.rb
index ea832569f..f2e3f7cc1 100644
--- a/spec/project/default_config_spec.rb
+++ b/spec/project/default_config_spec.rb
@@ -2,21 +2,13 @@
 
 RSpec.describe 'config/default.yml' do
   subject(:default_config) do
-    RuboCop::ConfigLoader.load_file('config/default.yml')
+    RuboCop::ConfigLoader.load_yaml_configuration('config/default.yml')
   end
 
-  let(:namespaces) do
-    {
-      'rspec' => 'RSpec',
-      'capybara' => 'Capybara',
-      'factory_bot' => 'FactoryBot',
-      'rails' => 'Rails'
-    }
-  end
+  let(:namespaces) { { 'rspec' => 'RSpec' } }
 
   let(:cop_names) do
-    glob = SpecHelper::ROOT.join('lib', 'rubocop', 'cop', 'rspec',
-                                 '{,capybara,factory_bot,rails}', '*.rb')
+    glob = SpecHelper::ROOT.join('lib', 'rubocop', 'cop', 'rspec', '*.rb')
     cop_names =
       Pathname.glob(glob).map do |file|
         file_name = file.basename('.rb').to_s
@@ -25,11 +17,27 @@
         "#{namespace}/#{cop_name}"
       end
 
-    cop_names - %w[RSpec/Cop]
+    cop_names - %w[RSpec/Base]
   end
 
   let(:config_keys) do
-    cop_names + %w[AllCops]
+    cop_names + namespaces.values
+  end
+
+  let(:unsafe_cops) do
+    require 'yard'
+    YARD::Registry.load!
+    YARD::Registry.all(:class).select do |example|
+      example.tags.any? { |tag| tag.tag_name == 'safety' }
+    end
+  end
+
+  let(:unsafe_cop_names) do
+    unsafe_cops.map do |cop|
+      dept_and_cop_names =
+        cop.path.split('::')[2..] # Drop `RuboCop::Cop` from class name.
+      dept_and_cop_names.join('/')
+    end
   end
 
   def cop_configuration(config_key)
@@ -42,17 +50,24 @@ def cop_configuration(config_key)
     end
   end
 
-  it 'has configuration for all cops' do
-    expect(default_config.keys).to match_array(config_keys)
+  it 'has configuration for all cops and amendments' do
+    expect(default_config.keys)
+      .to contain_exactly(*config_keys, 'Metrics/BlockLength')
   end
 
-  it 'sorts configuration keys alphabetically' do
-    namespaces.each do |_path, prefix|
-      expected = config_keys.select { |key| key.start_with?(prefix) }.sort
-      actual = default_config.keys.select { |key| key.start_with?(prefix) }
-      actual.each_with_index do |key, idx|
-        expect(key).to eq expected[idx]
-      end
+  it 'sorts configuration keys alphabetically with nested namespaces last' do
+    rspec_keys = default_config.keys.select { |key| key.start_with?('RSpec') }
+    namespaced_rspec_keys = rspec_keys.select do |key|
+      key.start_with?(*(namespaces.values - ['RSpec']))
+    end
+
+    expected = rspec_keys.sort_by do |key|
+      namespaced = namespaced_rspec_keys.include?(key) ? 1 : 0
+      "#{namespaced} #{key}"
+    end
+
+    rspec_keys.each_with_index do |key, idx|
+      expect(key).to eq expected[idx]
     end
   end
 
@@ -70,7 +85,35 @@ def cop_configuration(config_key)
     expect(cop_configuration('Description')).to all(end_with('.'))
   end
 
-  it 'includes Enabled: true for every cop' do
-    expect(cop_configuration('Enabled')).to all(be(true).or(be(false)))
+  it 'includes a valid Enabled for every cop' do
+    expect(cop_configuration('Enabled'))
+      .to all be(true).or(be(false)).or(eq('pending'))
+  end
+
+  it 'does not include unnecessary `SafeAutoCorrect: false`' do
+    cop_names.each do |cop_name|
+      next unless default_config.dig(cop_name, 'Safe') == false
+
+      safe_autocorrect = default_config.dig(cop_name, 'SafeAutoCorrect')
+
+      expect(safe_autocorrect).not_to(
+        be(false),
+        "`#{cop_name}` has unnecessary `SafeAutoCorrect: false` config."
+      )
+    end
+  end
+
+  it 'is expected that all cops documented with `@safety` are `Safe: false` ' \
+     'or `SafeAutoCorrect: false`' do
+    unsafe_cop_names.each do |cop_name|
+      unsafe = default_config[cop_name]['Safe'] == false ||
+        default_config[cop_name]['SafeAutoCorrect'] == false
+      expect(unsafe).to(
+        be(true),
+        "`#{cop_name}` cop should be set `Safe: false` or " \
+        '`SafeAutoCorrect: false` because `@safety` YARD tag exists.'
+      )
+      YARD::Registry.clear
+    end
   end
 end
diff --git a/spec/project/project_requires_spec.rb b/spec/project/project_requires_spec.rb
deleted file mode 100644
index 100f3f3c8..000000000
--- a/spec/project/project_requires_spec.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'Project requires' do
-  it 'alphabetizes cop requires' do
-    source   = SpecHelper::ROOT.join('lib', 'rubocop', 'cop', 'rspec_cops.rb')
-    captures = source.read.scan(%r{^(require_relative 'rspec/(.*?/)?(.*?)')$})
-
-    require_statements = captures.map(&:first)
-    sorted_require_statements =
-      captures.sort_by do |_require_statement, cop_category, name|
-        [cop_category || 'rspec', name]
-      end.map(&:first)
-
-    aggregate_failures do
-      # Sanity check that we actually discovered require statements.
-      expect(captures).not_to be_empty
-      expect(require_statements).to eql(sorted_require_statements)
-    end
-  end
-end
diff --git a/spec/rubocop/cli/autocorrect_spec.rb b/spec/rubocop/cli/autocorrect_spec.rb
new file mode 100644
index 000000000..abcd75082
--- /dev/null
+++ b/spec/rubocop/cli/autocorrect_spec.rb
@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe 'RuboCop::CLI --autocorrect' do # rubocop:disable RSpec/DescribeClass
+  subject(:cli) { RuboCop::CLI.new }
+
+  include_context 'isolated environment'
+
+  include_context 'when cli spec behavior'
+
+  context 'when corrects `RSpec/AlignLeftLetBrace` and ' \
+          '`RSpec/AlignRightLetBrace` with `Layout/ExtraSpacing`' do
+    before do
+      RuboCop::ConfigLoader
+        .default_configuration
+        .for_all_cops['SuggestExtensions'] = false
+
+      create_file('.rubocop.yml', <<~YAML)
+        RSpec/AlignLeftLetBrace:
+          Enabled: true
+        RSpec/AlignRightLetBrace:
+          Enabled: true
+      YAML
+
+      create_file('spec/example.rb', <<~RUBY)
+        let(:foobar) { blahblah }
+        let(:baz) { bar }
+        let(:a) { b }
+      RUBY
+    end
+
+    it 'rubocop terminates with a success' do
+      expect(cli.run(['-A', '--only',
+                      'RSpec/AlignLeftLetBrace,' \
+                      'RSpec/AlignRightLetBrace,' \
+                      'Layout/ExtraSpacing'])).to eq(0)
+    end
+
+    it 'autocorrects be compatible with each other' do
+      cli.run(['-A', '--only',
+               'RSpec/AlignLeftLetBrace,' \
+               'RSpec/AlignRightLetBrace,' \
+               'Layout/ExtraSpacing'])
+
+      expect(File.read('spec/example.rb')).to eq(<<~RUBY)
+        let(:foobar) { blahblah }
+        let(:baz)    { bar      }
+        let(:a)      { b        }
+      RUBY
+    end
+  end
+
+  context 'when corrects `RSpec/LetBeforeExamples` with ' \
+          '`RSpec/ScatteredLet`' do
+    before do
+      RuboCop::ConfigLoader
+        .default_configuration
+        .for_all_cops['SuggestExtensions'] = false
+
+      create_file('spec/example.rb', <<~RUBY)
+        RSpec.describe 'Foo' do
+          let(:params) { {} }
+
+          specify do
+            expect(true).to be true
+          end
+
+          let(:attributes) { %i[first_name last_name] }
+        end
+      RUBY
+    end
+
+    it 'rubocop terminates with a success' do
+      expect(cli.run(['-A', '--only',
+                      'RSpec/LetBeforeExamples,' \
+                      'RSpec/ScatteredLet'])).to eq(0)
+    end
+
+    it 'autocorrects be compatible with each other' do
+      cli.run(['-A', '--only',
+               'RSpec/LetBeforeExamples,' \
+               'RSpec/ScatteredLet'])
+
+      expect(File.read('spec/example.rb')).to eq(<<~RUBY)
+        RSpec.describe 'Foo' do
+          let(:params) { {} }
+
+          let(:attributes) { %i[first_name last_name] }
+          specify do
+            expect(true).to be true
+          end
+
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cli/run_spec.rb b/spec/rubocop/cli/run_spec.rb
new file mode 100644
index 000000000..4b0f6ba7b
--- /dev/null
+++ b/spec/rubocop/cli/run_spec.rb
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+RSpec.describe 'RuboCop::CLI run', :isolated_environment do # rubocop:disable RSpec/DescribeClass
+  subject(:cli) { RuboCop::CLI.new }
+
+  include_context 'when cli spec behavior'
+
+  context 'when set option `AllowedIdentifiers` for ' \
+          '`RSpec/IndexedLet` and `Naming/VariableNumber`' do
+    let(:exit_code) do
+      cli.run(%w[--format simple --only RSpec/IndexedLet,Naming/VariableNumber])
+    end
+
+    it 'does not offense for `RSpec/IndexedLet` ' \
+       'when set `AllowedIdentifiers` in `Naming/VariableNumber`' do
+      create_file('.rubocop.yml', <<~YAML)
+        RSpec/IndexedLet:
+          Enabled: true
+          AllowedPatterns:
+            - foo
+        Naming/VariableNumber:
+          Enabled: true
+          AllowedIdentifiers:
+            - bar_1
+            - bar_2
+      YAML
+      create_file('spec/example.rb', <<~RUBY)
+        describe SomeService do
+          let(:foo_1) { create(:foo) }
+          let(:foo_2) { create(:foo) }
+          let(:bar_1) { create(:bar) }
+          let(:bar_2) { create(:bar) }
+          let(:baz_1) { create(:baz) }
+          let(:baz_2) { create(:baz) }
+        end
+      RUBY
+      expect(exit_code).to eq(1)
+      expect($stdout.string).to eq(<<~OUTPUT)
+        == spec/example.rb ==
+        C:  2:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  3:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  6:  3: RSpec/IndexedLet: This let statement uses 1 in its name. Please give it a meaningful name.
+        C:  6:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  7:  3: RSpec/IndexedLet: This let statement uses 2 in its name. Please give it a meaningful name.
+        C:  7:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+
+        1 file inspected, 6 offenses detected
+      OUTPUT
+    end
+  end
+
+  context 'when set option `AllowedPatterns` for ' \
+          '`RSpec/IndexedLet` and `Naming/VariableNumber`' do
+    let(:exit_code) do
+      cli.run(%w[--format simple --only RSpec/IndexedLet,Naming/VariableNumber])
+    end
+
+    it 'does not offense for `RSpec/IndexedLet` ' \
+       'when set `AllowedPatterns` in `Naming/VariableNumber`' do
+      create_file('.rubocop.yml', <<~YAML)
+        RSpec/IndexedLet:
+          Enabled: true
+          AllowedPatterns:
+            - foo
+        Naming/VariableNumber:
+          Enabled: true
+          AllowedPatterns:
+            - bar
+      YAML
+      create_file('spec/example.rb', <<~RUBY)
+        describe SomeService do
+          let(:foo_1) { create(:foo) }
+          let(:foo_2) { create(:foo) }
+          let(:bar_1) { create(:bar) }
+          let(:bar_2) { create(:bar) }
+          let(:baz_1) { create(:baz) }
+          let(:baz_2) { create(:baz) }
+        end
+      RUBY
+      expect(exit_code).to eq(1)
+      expect($stdout.string).to eq(<<~OUTPUT)
+        == spec/example.rb ==
+        C:  2:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  3:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  6:  3: RSpec/IndexedLet: This let statement uses 1 in its name. Please give it a meaningful name.
+        C:  6:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+        C:  7:  3: RSpec/IndexedLet: This let statement uses 2 in its name. Please give it a meaningful name.
+        C:  7:  7: Naming/VariableNumber: Use normalcase for symbol numbers.
+
+        1 file inspected, 6 offenses detected
+      OUTPUT
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/align_left_let_brace_spec.rb b/spec/rubocop/cop/rspec/align_left_let_brace_spec.rb
index e923f8003..c350a04ff 100644
--- a/spec/rubocop/cop/rspec/align_left_let_brace_spec.rb
+++ b/spec/rubocop/cop/rspec/align_left_let_brace_spec.rb
@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::AlignLeftLetBrace do
-  subject(:cop) { described_class.new }
-
-  # rubocop:disable RSpec/ExampleLength
   it 'registers offense for unaligned braces' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       let(:foo) { bar }
                 ^ Align left let brace
       let(:hi) { baz }
@@ -26,7 +23,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       let(:foo)      { bar }
       let(:hi)       { baz }
       let(:blahblah) { baz }
@@ -43,9 +40,14 @@
       end
     RUBY
   end
-  # rubocop:enable RSpec/ExampleLength
 
-  it 'works with empty file' do
+  it 'does not register an offense for let with proc argument' do
+    expect_no_offenses(<<~RUBY)
+      let(:user, &args[:build_user])
+    RUBY
+  end
+
+  it 'does not register an offense with empty file' do
     expect_no_offenses('')
   end
 end
diff --git a/spec/rubocop/cop/rspec/align_right_let_brace_spec.rb b/spec/rubocop/cop/rspec/align_right_let_brace_spec.rb
index 6a2c0028a..c1ee4f0e6 100644
--- a/spec/rubocop/cop/rspec/align_right_let_brace_spec.rb
+++ b/spec/rubocop/cop/rspec/align_right_let_brace_spec.rb
@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::AlignRightLetBrace do
-  subject(:cop) { described_class.new }
-
-  # rubocop:disable RSpec/ExampleLength
   it 'registers offense for unaligned braces' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       let(:foo)      { a }
                          ^ Align right let brace
       let(:hi)       { ab }
@@ -26,7 +23,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       let(:foo)      { a    }
       let(:hi)       { ab   }
       let(:blahblah) { abcd }
@@ -43,9 +40,14 @@
       end
     RUBY
   end
-  # rubocop:enable RSpec/ExampleLength
 
-  it 'works with empty file' do
+  it 'does not register an offense for let with proc argument' do
+    expect_no_offenses(<<~RUBY)
+      let(:user, &args[:build_user])
+    RUBY
+  end
+
+  it 'does not register an offense with empty file' do
     expect_no_offenses('')
   end
 end
diff --git a/spec/rubocop/cop/rspec/any_instance_spec.rb b/spec/rubocop/cop/rspec/any_instance_spec.rb
index 22f3c860d..860424be9 100644
--- a/spec/rubocop/cop/rspec/any_instance_spec.rb
+++ b/spec/rubocop/cop/rspec/any_instance_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::AnyInstance do
-  subject(:cop) { described_class.new }
-
   it 'finds `allow_any_instance_of` instead of an instance double' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         allow_any_instance_of(Object).to receive(:foo)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `allow_any_instance_of`.
@@ -13,7 +11,7 @@
   end
 
   it 'finds `expect_any_instance_of` instead of an instance double' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         expect_any_instance_of(Object).to receive(:foo)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `expect_any_instance_of`.
@@ -22,7 +20,7 @@
   end
 
   it 'finds old `any_instance` syntax instead of an instance double' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         Object.any_instance.should_receive(:foo)
         ^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `any_instance`.
diff --git a/spec/rubocop/cop/rspec/around_block_spec.rb b/spec/rubocop/cop/rspec/around_block_spec.rb
index c5c9ce781..301f452b4 100644
--- a/spec/rubocop/cop/rspec/around_block_spec.rb
+++ b/spec/rubocop/cop/rspec/around_block_spec.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::AroundBlock do
-  subject(:cop) { described_class.new }
-
   context 'when no value is yielded' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around do
         ^^^^^^^^^ Test object should be passed to around block.
           do_something
@@ -16,7 +14,7 @@
 
   context 'when the hook is scoped with a symbol' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around(:each) do
         ^^^^^^^^^^^^^^^^ Test object should be passed to around block.
           do_something
@@ -27,7 +25,7 @@
 
   context 'when the yielded value is unused' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around do |test|
                    ^^^^ You should call `test.call` or `test.run`.
           do_something
@@ -38,7 +36,7 @@
 
   context 'when two values are yielded and the first is unused' do
     it 'registers an offense for the first argument' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around do |test, unused|
                    ^^^^ You should call `test.call` or `test.run`.
           unused.run
@@ -49,7 +47,7 @@
 
   context 'when the yielded value is referenced but not used' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around do |test|
                    ^^^^ You should call `test.call` or `test.run`.
           test
@@ -60,7 +58,7 @@
 
   context 'when a method other than #run or #call is called' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         around do |test|
                    ^^^^ You should call `test.call` or `test.run`.
           test.inspect
@@ -71,7 +69,7 @@
 
   context 'when #run is called' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         around do |test|
           test.run
         end
@@ -81,7 +79,7 @@
 
   context 'when #call is called' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         around do |test|
           test.call
         end
@@ -91,7 +89,7 @@
 
   context 'when used as a block arg' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         around do |test|
           1.times(&test)
         end
@@ -101,7 +99,7 @@
 
   context 'when passed to another method' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         around do |test|
           something_that_might_run_test(test, another_arg)
         end
@@ -111,11 +109,73 @@
 
   context 'when yielded to another block' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         around do |test|
           foo { yield(some_arg, test) }
         end
       RUBY
     end
   end
+
+  context 'when Ruby 2.7', :ruby27 do
+    context 'when the yielded value is unused' do
+      it 'registers an offense' do
+        expect_offense(<<~RUBY)
+          around { _1 }
+                   ^^ You should call `_1.call` or `_1.run`.
+        RUBY
+      end
+    end
+
+    context 'when a method other than #run or #call is called' do
+      it 'registers an offense' do
+        expect_offense(<<~RUBY)
+          around do
+            _1.inspect
+            ^^^^^^^^^^ You should call `_1.call` or `_1.run`.
+          end
+        RUBY
+      end
+    end
+
+    context 'when #run is called' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          around do
+            _1.run
+          end
+        RUBY
+      end
+    end
+
+    context 'when #call is called' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          around do
+            _1.call
+          end
+        RUBY
+      end
+    end
+
+    context 'when used as a block arg' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          around do
+            1.times(&_1)
+          end
+        RUBY
+      end
+    end
+
+    context 'when passed to another method' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          around do
+            something_that_might_run_test(_1, another_arg)
+          end
+        RUBY
+      end
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/base_spec.rb b/spec/rubocop/cop/rspec/base_spec.rb
new file mode 100644
index 000000000..caba2662a
--- /dev/null
+++ b/spec/rubocop/cop/rspec/base_spec.rb
@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::Base do
+  let(:cop_class) { RuboCop::RSpec::FakeCop }
+  let(:cop_config) { { 'Exclude' => %w[bar_spec.rb] } }
+
+  before do
+    stub_const('RuboCop::RSpec::FakeCop',
+               Class.new(described_class) do
+                 def on_send(node)
+                   add_offense(node, message: 'I flag everything')
+                 end
+               end)
+  end
+
+  context 'when the source path ends with `_spec.rb`' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY, 'foo_spec.rb')
+        foo(1)
+        ^^^^^^ I flag everything
+      RUBY
+    end
+
+    it 'ignores the file if it is ignored' do
+      expect_no_offenses(<<~RUBY, 'bar_spec.rb')
+        foo(1)
+      RUBY
+    end
+  end
+
+  context 'when the source path contains `/spec/`' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY, '/spec/support/thing.rb')
+        foo(1)
+        ^^^^^^ I flag everything
+      RUBY
+    end
+  end
+
+  context 'when the source path starts with `spec/`' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY, 'spec/support/thing.rb')
+        foo(1)
+        ^^^^^^ I flag everything
+      RUBY
+    end
+  end
+
+  context 'when the file is a source file without "spec" in the name' do
+    it 'ignores the source when the path is not a spec file' do
+      expect_no_offenses(<<~RUBY, 'foo.rb')
+        foo(1)
+      RUBY
+    end
+
+    it 'ignores the source when the path is not a specified pattern' do
+      expect_no_offenses(<<~RUBY, 'foo_test.rb')
+        foo(1)
+      RUBY
+    end
+  end
+
+  context 'when custom patterns are specified' do
+    let(:other_cops) do
+      {
+        'RSpec' => {
+          'Include' => ['*_test\.rb']
+        }
+      }
+    end
+
+    it 'registers offenses when the path matches a custom specified pattern' do
+      expect_offense(<<~RUBY, 'foo_test.rb')
+        foo(1)
+        ^^^^^^ I flag everything
+      RUBY
+    end
+  end
+
+  describe 'DSL alias configuration' do
+    before do
+      stub_const('RuboCop::RSpec::ExampleGroupHaterCop',
+                 Class.new(described_class) do
+                   def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+                     example_group?(node) do
+                       add_offense(node, message: 'I flag example groups')
+                     end
+                   end
+                 end)
+    end
+
+    let(:cop_class) { RuboCop::RSpec::ExampleGroupHaterCop }
+
+    shared_examples_for 'it detects `describe`' do
+      it 'detects `describe` as an example group' do
+        expect_offense(<<~RUBY)
+          describe 'ouch oh' do
+          ^^^^^^^^^^^^^^^^^^^^^ I flag example groups
+            it { }
+          end
+        RUBY
+      end
+    end
+
+    context 'with the default config' do
+      it 'does not detect `epic` as an example group' do
+        expect_no_offenses(<<~RUBY)
+          epic 'great achievements or events is narrated in elevated style' do
+            ballad 'slays Minotaur' do
+              # ...
+            end
+          end
+        RUBY
+      end
+
+      it_behaves_like 'it detects `describe`'
+    end
+
+    context 'when `epic` is set as an alias to example group' do
+      before do
+        other_cops.dig('RSpec', 'Language', 'ExampleGroups', 'Regular')
+          .push('epic')
+      end
+
+      it 'detects `epic` as an example group' do
+        expect_offense(<<~RUBY)
+          epic 'great achievements or events is narrated in elevated style' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ I flag example groups
+            ballad 'slays Minotaur' do
+              # ...
+            end
+          end
+        RUBY
+      end
+
+      it_behaves_like 'it detects `describe`'
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/be_empty_spec.rb b/spec/rubocop/cop/rspec/be_empty_spec.rb
new file mode 100644
index 000000000..58c6cee12
--- /dev/null
+++ b/spec/rubocop/cop/rspec/be_empty_spec.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::BeEmpty do
+  it 'registers an offense when using `expect(array).to contain_exactly`' do
+    expect_offense(<<~RUBY)
+      expect(array).to contain_exactly
+                       ^^^^^^^^^^^^^^^ Use `be_empty` matchers for checking an empty array.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(array).to be_empty
+    RUBY
+  end
+
+  it 'registers an offense when ' \
+     'using `expect(array).to contain_exactly, "with a message"`' do
+    expect_offense(<<~RUBY)
+      expect(array).to contain_exactly, "with a message"
+                       ^^^^^^^^^^^^^^^ Use `be_empty` matchers for checking an empty array.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(array).to be_empty, "with a message"
+    RUBY
+  end
+
+  it 'registers an offense when using `expect(array).to match_array([])`' do
+    expect_offense(<<~RUBY)
+      expect(array).to match_array([])
+                       ^^^^^^^^^^^^^^^ Use `be_empty` matchers for checking an empty array.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(array).to be_empty
+    RUBY
+  end
+
+  it 'registers an offense when ' \
+     'using `expect(array).to match_array([]), "with a message"`' do
+    expect_offense(<<~RUBY)
+      expect(array).to match_array([]), "with a message"
+                       ^^^^^^^^^^^^^^^ Use `be_empty` matchers for checking an empty array.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(array).to be_empty, "with a message"
+    RUBY
+  end
+
+  it 'does not register an offense when using `expect(array).to be_empty`' do
+    expect_no_offenses(<<~RUBY)
+      expect(array).to be_empty
+    RUBY
+  end
+
+  it 'does not register an offense when ' \
+     'using `expect(array).to be_empty, "with a message"`' do
+    expect_no_offenses(<<~RUBY)
+      expect(array).to be_empty, "with a message"
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/be_eq_spec.rb b/spec/rubocop/cop/rspec/be_eq_spec.rb
new file mode 100644
index 000000000..2c659e14d
--- /dev/null
+++ b/spec/rubocop/cop/rspec/be_eq_spec.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::BeEq do
+  it 'registers an offense for `eq` when argument is a boolean' do
+    expect_offense(<<~RUBY)
+      it { expect(foo).to eq(true) }
+                          ^^ Prefer `be` over `eq`.
+      it { expect(foo).not_to eq(true) }
+                              ^^ Prefer `be` over `eq`.
+      it { expect(foo).to_not eq(true) }
+                              ^^ Prefer `be` over `eq`.
+      it { expect(foo).to eq(false) }
+                          ^^ Prefer `be` over `eq`.
+      it { expect(foo).not_to eq(false) }
+                              ^^ Prefer `be` over `eq`.
+      it { expect(foo).to_not eq(false) }
+                              ^^ Prefer `be` over `eq`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { expect(foo).to be(true) }
+      it { expect(foo).not_to be(true) }
+      it { expect(foo).to_not be(true) }
+      it { expect(foo).to be(false) }
+      it { expect(foo).not_to be(false) }
+      it { expect(foo).to_not be(false) }
+    RUBY
+  end
+
+  it 'registers an offense for `eq` when argument is nil' do
+    expect_offense(<<~RUBY)
+      it { expect(foo).to eq(nil) }
+                          ^^ Prefer `be` over `eq`.
+      it { expect(foo).not_to eq(nil) }
+                              ^^ Prefer `be` over `eq`.
+      it { expect(foo).to_not eq(nil) }
+                              ^^ Prefer `be` over `eq`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { expect(foo).to be(nil) }
+      it { expect(foo).not_to be(nil) }
+      it { expect(foo).to_not be(nil) }
+    RUBY
+  end
+
+  it 'does not register an offense for `eq` when argument is an integer' do
+    expect_no_offenses(<<~RUBY)
+      it { expect(foo).to eq(0) }
+      it { expect(foo).to eq(123) }
+    RUBY
+  end
+
+  it 'does not register an offense for `eq` when argument is a float' do
+    expect_no_offenses(<<~RUBY)
+      it { expect(foo).to eq(1.0) }
+      it { expect(foo).to eq(1.23) }
+    RUBY
+  end
+
+  it 'does not register an offense for `eq` when argument is a symbol' do
+    expect_no_offenses(<<~RUBY)
+      it { expect(foo).to eq(:foo) }
+    RUBY
+  end
+
+  it 'does not register an offense for `eq` when argument is a string' do
+    expect_no_offenses(<<~RUBY)
+      it { expect(foo).to eq('foo') }
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/be_eql_spec.rb b/spec/rubocop/cop/rspec/be_eql_spec.rb
index c03480421..6ae4d6b76 100644
--- a/spec/rubocop/cop/rspec/be_eql_spec.rb
+++ b/spec/rubocop/cop/rspec/be_eql_spec.rb
@@ -1,80 +1,78 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::BeEql do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for `eql` when argument is a boolean' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to eql(true) }
                           ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(false) }
                           ^^^ Prefer `be` over `eql`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       it { expect(foo).to be(true) }
       it { expect(foo).to be(false) }
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is an integer' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to eql(0) }
                           ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(123) }
                           ^^^ Prefer `be` over `eql`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       it { expect(foo).to be(0) }
       it { expect(foo).to be(123) }
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is a float' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to eql(1.0) }
                           ^^^ Prefer `be` over `eql`.
       it { expect(foo).to eql(1.23) }
                           ^^^ Prefer `be` over `eql`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       it { expect(foo).to be(1.0) }
       it { expect(foo).to be(1.23) }
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is a symbol' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to eql(:foo) }
                           ^^^ Prefer `be` over `eql`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       it { expect(foo).to be(:foo) }
     RUBY
   end
 
   it 'registers an offense for `eql` when argument is nil' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to eql(nil) }
                           ^^^ Prefer `be` over `eql`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       it { expect(foo).to be(nil) }
     RUBY
   end
 
   it 'does not register an offense for `eql` when argument is a string' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it { expect(foo).to eql('foo') }
     RUBY
   end
 
   it 'does not register an offense for `eql` when expectation is negated' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it { expect(foo).to_not eql(1) }
     RUBY
   end
diff --git a/spec/rubocop/cop/rspec/be_nil_spec.rb b/spec/rubocop/cop/rspec/be_nil_spec.rb
new file mode 100644
index 000000000..3405f6d75
--- /dev/null
+++ b/spec/rubocop/cop/rspec/be_nil_spec.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::BeNil do
+  let(:cop_config) do
+    { 'EnforcedStyle' => enforced_style }
+  end
+
+  context 'with EnforcedStyle `be_nil`' do
+    let(:enforced_style) { 'be_nil' }
+
+    it 'registers an offense when using `#be` for `nil` value' do
+      expect_offense(<<~RUBY)
+        expect(foo).to be(nil)
+                       ^^^^^^^ Prefer `be_nil` over `be(nil)`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(foo).to be_nil
+      RUBY
+    end
+
+    it 'does not register an offense when using `#be_nil`' do
+      expect_no_offenses(<<~RUBY)
+        expect(foo).to be_nil
+      RUBY
+    end
+
+    it 'does not register an offense when using `#be` with other values' do
+      expect_no_offenses(<<~RUBY)
+        expect(foo).to be(true)
+        expect(foo).to be(false)
+        expect(foo).to be(1)
+        expect(foo).to be("yes")
+        expect(foo).to be(Class.new)
+      RUBY
+    end
+  end
+
+  context 'with EnforcedStyle `be`' do
+    let(:enforced_style) { 'be' }
+
+    it 'does not register an offense when using `#be` for `nil` value' do
+      expect_no_offenses(<<~RUBY)
+        expect(foo).to be(nil)
+      RUBY
+    end
+
+    it 'registers an offense when using `#be_nil`' do
+      expect_offense(<<~RUBY)
+        expect(foo).to be_nil
+                       ^^^^^^ Prefer `be(nil)` over `be_nil`.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        expect(foo).to be(nil)
+      RUBY
+    end
+
+    it 'does not register an offense when using other `#be_*` methods' do
+      expect_no_offenses(<<~RUBY)
+        expect(foo).to be_truthy
+        expect(foo).to be_falsey
+        expect(foo).to be_fooish
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/be_spec.rb b/spec/rubocop/cop/rspec/be_spec.rb
index c8c02ddaa..770de2eff 100644
--- a/spec/rubocop/cop/rspec/be_spec.rb
+++ b/spec/rubocop/cop/rspec/be_spec.rb
@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::Be do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for `be` without an argument' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).to be }
                           ^^ Don't use `be` without an argument.
     RUBY
   end
 
   it 'registers an offense for not_to be' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it { expect(foo).not_to be }
                               ^^ Don't use `be` without an argument.
       it { expect(foo).to_not be }
@@ -20,14 +18,14 @@
   end
 
   it 'allows `be` with an argument' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it { expect(foo).to be(1) }
       it { expect(foo).not_to be(0) }
     RUBY
   end
 
   it 'allows specific `be_` matchers' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it { expect(foo).to be_truthy }
       it { expect(foo).not_to be_falsy }
     RUBY
diff --git a/spec/rubocop/cop/rspec/before_after_all_spec.rb b/spec/rubocop/cop/rspec/before_after_all_spec.rb
index 2e67c2250..934e0b8af 100644
--- a/spec/rubocop/cop/rspec/before_after_all_spec.rb
+++ b/spec/rubocop/cop/rspec/before_after_all_spec.rb
@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::BeforeAfterAll do
-  subject(:cop) { described_class.new }
-
   def message(hook)
-    "Beware of using `#{hook}` as it may cause state to leak between tests. "\
-    'If you are using `rspec-rails`, and `use_transactional_fixtures` is '\
-    "enabled, then records created in `#{hook}` are not automatically rolled "\
-    'back.'
+    "Beware of using `#{hook}` as it may cause state to leak between tests. " \
+      'If you are using `rspec-rails`, and `use_transactional_fixtures` is ' \
+      "enabled, then records created in `#{hook}` are not automatically " \
+      'rolled back.'
   end
 
   context 'when using before all' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before(:all) { do_something }
         ^^^^^^^^^^^^ #{message('before(:all)')}
         before(:context) { do_something }
@@ -23,7 +21,7 @@ def message(hook)
 
   context 'when using after all' do
     it 'registers an offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         after(:all) { do_something }
         ^^^^^^^^^^^ #{message('after(:all)')}
         after(:context) { do_something }
@@ -34,7 +32,7 @@ def message(hook)
 
   context 'when using before each' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before(:each) { do_something }
         before(:example) { do_something }
       RUBY
@@ -43,7 +41,7 @@ def message(hook)
 
   context 'when using after each' do
     it 'does not register an offense' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         after(:each) { do_something }
         after(:example) { do_something }
       RUBY
diff --git a/spec/rubocop/cop/rspec/capybara/current_path_expectation_spec.rb b/spec/rubocop/cop/rspec/capybara/current_path_expectation_spec.rb
deleted file mode 100644
index 78616663d..000000000
--- a/spec/rubocop/cop/rspec/capybara/current_path_expectation_spec.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Capybara::CurrentPathExpectation do
-  subject(:cop) { described_class.new }
-
-  it 'flags violations for `expect(current_path)`' do
-    expect_offense(<<-RUBY)
-      expect(current_path).to eq("/callback")
-      ^^^^^^ Do not set an RSpec expectation on `current_path` in Capybara feature specs - instead, use the `have_current_path` matcher on `page`
-    RUBY
-  end
-
-  it 'flags violations for `expect(page.current_path)`' do
-    expect_offense(<<-RUBY)
-      expect(page.current_path).to eq("/callback")
-      ^^^^^^ Do not set an RSpec expectation on `current_path` in Capybara feature specs - instead, use the `have_current_path` matcher on `page`
-    RUBY
-  end
-
-  it "doesn't flag a violation for other expectations" do
-    expect_no_offenses(<<-RUBY)
-      expect(current_user).to eq(user)
-    RUBY
-  end
-
-  it "doesn't flag a violation for other references to `current_path`" do
-    expect_no_offenses(<<-RUBY)
-      current_path = WalkingRoute.last.path
-    RUBY
-  end
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to eq expected_path',
-                   'expect(page).to have_current_path expected_path, '\
-                   'ignore_query: true'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to eq(expected_path)',
-                   'expect(page).to have_current_path(expected_path, '\
-                   'ignore_query: true)'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to(eq(expected_path))',
-                   'expect(page).to(have_current_path(expected_path, '\
-                   'ignore_query: true))'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to eq(expected_path(f: :b))',
-                   'expect(page).to have_current_path(expected_path(f: :b), '\
-                   'ignore_query: true)'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to eq(foo(bar).path)',
-                   'expect(page).to have_current_path(foo(bar).path, '\
-                   'ignore_query: true)'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).not_to eq expected_path',
-                   'expect(page).to have_no_current_path expected_path, '\
-                   'ignore_query: true'
-
-  include_examples 'autocorrect',
-                   'expect(current_path).to_not eq expected_path',
-                   'expect(page).to have_no_current_path expected_path, '\
-                   'ignore_query: true'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match(/regexp/i)',
-                   'expect(page).to have_current_path(/regexp/i)'
-
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match("string/")',
-                   'expect(page).to have_current_path(/string\//)'
-
-  # Unsupported, no change.
-  include_examples 'autocorrect',
-                   'expect(page.current_path).to match(variable)',
-                   'expect(page.current_path).to match(variable)'
-
-  # Unsupported, no change.
-  include_examples 'autocorrect',
-                   'expect(page.current_path)',
-                   'expect(page.current_path)'
-end
diff --git a/spec/rubocop/cop/rspec/capybara/feature_methods_spec.rb b/spec/rubocop/cop/rspec/capybara/feature_methods_spec.rb
deleted file mode 100644
index 6626e1bc1..000000000
--- a/spec/rubocop/cop/rspec/capybara/feature_methods_spec.rb
+++ /dev/null
@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Capybara::FeatureMethods, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'EnabledMethods' => [] } }
-
-  it 'flags violations for `background`' do
-    expect_offense(<<-RUBY)
-      describe 'some feature' do
-        background do; end
-        ^^^^^^^^^^ Use `before` instead of `background`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `scenario`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe 'some feature' do
-        scenario 'Foo' do; end
-        ^^^^^^^^ Use `it` instead of `scenario`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `xscenario`' do
-    expect_offense(<<-RUBY)
-      describe 'Foo' do
-        RSpec.xscenario 'Baz' do; end
-              ^^^^^^^^^ Use `xit` instead of `xscenario`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `given`' do
-    expect_offense(<<-RUBY)
-      RSpec.describe 'Foo' do
-        given(:foo) { :foo }
-        ^^^^^ Use `let` instead of `given`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `given!`' do
-    expect_offense(<<-RUBY)
-      describe 'Foo' do
-        given!(:foo) { :foo }
-        ^^^^^^ Use `let!` instead of `given!`.
-      end
-    RUBY
-  end
-
-  it 'flags violations for `feature`' do
-    expect_offense(<<-RUBY)
-      RSpec.feature 'Foo' do; end
-            ^^^^^^^ Use `describe` instead of `feature`.
-    RUBY
-  end
-
-  it 'ignores variables inside examples' do
-    expect_no_offenses(<<-RUBY)
-      it 'is valid code' do
-        given(feature)
-        assign(background)
-        run scenario
-      end
-    RUBY
-  end
-
-  it 'ignores feature calls outside spec' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :company do
-          feature { "a company" }
-          background { Faker::Lorem.sentence }
-        end
-      end
-    RUBY
-  end
-
-  it 'allows includes before the spec' do
-    expect_offense(<<-RUBY)
-      require 'rails_helper'
-
-      RSpec.feature 'Foo' do; end
-            ^^^^^^^ Use `describe` instead of `feature`.
-    RUBY
-  end
-
-  context 'with configured `EnabledMethods`' do
-    let(:cop_config) { { 'EnabledMethods' => %w[feature] } }
-
-    it 'ignores usage of the enabled method' do
-      expect_no_offenses(<<-RUBY)
-        RSpec.feature 'feature is enabled' do; end
-      RUBY
-    end
-
-    it 'flags other methods' do
-      expect_offense(<<-RUBY)
-        RSpec.feature 'feature is enabled' do
-          given(:foo) { :foo }
-          ^^^^^ Use `let` instead of `given`.
-        end
-      RUBY
-    end
-  end
-
-  shared_examples 'autocorrect_spec' do |original, corrected|
-    original = <<-RUBY
-      describe Foo do
-        #{original}
-      end
-    RUBY
-    corrected = <<-RUBY
-      describe Foo do
-        #{corrected}
-      end
-    RUBY
-
-    include_examples 'autocorrect', original, corrected
-  end
-
-  include_examples 'autocorrect_spec', 'background { }',    'before { }'
-  include_examples 'autocorrect_spec', 'scenario { }',      'it { }'
-  include_examples 'autocorrect_spec', 'xscenario { }',     'xit { }'
-  include_examples 'autocorrect_spec', 'given(:foo) { }',   'let(:foo) { }'
-  include_examples 'autocorrect_spec', 'given!(:foo) { }',  'let!(:foo) { }'
-  include_examples 'autocorrect_spec', 'RSpec.feature { }', 'RSpec.describe { }'
-end
diff --git a/spec/rubocop/cop/rspec/change_by_zero_spec.rb b/spec/rubocop/cop/rspec/change_by_zero_spec.rb
new file mode 100644
index 000000000..675716fee
--- /dev/null
+++ b/spec/rubocop/cop/rspec/change_by_zero_spec.rb
@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ChangeByZero do
+  it 'registers an offense when using `change` and argument to `by` is zero' do
+    expect_offense(<<~RUBY)
+      it do
+        expect { foo }.to change(Foo, :bar).by(0)
+                          ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.to change(::Foo, :bar).by(0)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.to change { Foo.bar }.by(0)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+        expect { foo }.to change(Foo, :bar).by 0
+                          ^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to change.by(0)`.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it do
+        expect { foo }.not_to change(Foo, :bar)
+        expect { foo }.not_to change(::Foo, :bar)
+        expect { foo }.not_to change { Foo.bar }
+        expect { foo }.not_to change(Foo, :bar)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `a_block_changing` ' \
+     'and argument to `by` is zero' do
+    expect_offense(<<~RUBY)
+      it do
+        expect { foo }.to a_block_changing(Foo, :bar).by(0)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to a_block_changing.by(0)`.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it do
+        expect { foo }.not_to change(Foo, :bar)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `changing` ' \
+     'and argument to `by` is zero' do
+    expect_offense(<<~RUBY)
+      it do
+        expect { foo }.to changing(Foo, :bar).by(0)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to change` over `to changing.by(0)`.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it do
+        expect { foo }.not_to change(Foo, :bar)
+      end
+    RUBY
+  end
+
+  context 'when `NegatedMatcher` is not defined (default)' do
+    it 'registers an offense when the argument to `by` is zero ' \
+       'with compound expectations by `and`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }.to change(Foo, :bar).by(0).and change(Foo, :baz).by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                        ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0).and change { Foo.baz }.by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                         ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change(Foo, :bar).by(0).and change(Foo, :baz)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.and change { Foo.baz }.by(0)
+                                                   ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'registers an offense when the argument to `by` is zero ' \
+       'with compound expectations by `&`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }.to change(Foo, :bar).by(0) & change(Foo, :baz).by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                      ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0) & change { Foo.baz }.by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                       ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change(Foo, :bar).by(0) & change(Foo, :baz)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar } & change { Foo.baz }.by(0)
+                                                 ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'registers an offense when the argument to `by` is zero ' \
+       'with compound expectations by `or`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }.to change(Foo, :bar).by(0).or change(Foo, :baz).by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                       ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0).or change { Foo.baz }.by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                        ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change(Foo, :bar).by(0).or change(Foo, :baz)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.or change { Foo.baz }.by(0)
+                                                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'registers an offense when the argument to `by` is zero ' \
+       'with compound expectations by `|`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }.to change(Foo, :bar).by(0) | change(Foo, :baz).by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                      ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0) | change { Foo.baz }.by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                                                       ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change(Foo, :bar) | change(Foo, :baz).by(0)
+                                                ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0) | change { Foo.baz }
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    context 'when with a line break' do
+      it 'registers an offense when the argument to `by` is zero ' \
+         'with compound expectations by `and`' do
+        expect_offense(<<~RUBY)
+          it do
+            expect { foo }
+              .to change(Foo, :bar).by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              .and change(Foo, :baz).by(0)
+                   ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+            expect { foo }
+              .to change { Foo.bar }.by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              .and change { Foo.baz }.by(0)
+                   ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          end
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense when the argument to `by` is zero ' \
+         'with compound expectations by `&`' do
+        expect_offense(<<~RUBY)
+          it do
+            expect { foo }
+              .to change(Foo, :bar).by(0) &
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                  change(Foo, :baz).by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+            expect { foo }
+              .to change { Foo.bar }.by(0) &
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                  change { Foo.baz }.by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          end
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense when the argument to `by` is zero ' \
+         'with compound expectations by `or`' do
+        expect_offense(<<~RUBY)
+          it do
+            expect { foo }
+              .to change(Foo, :bar).by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              .or change(Foo, :baz).by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+            expect { foo }
+              .to change { Foo.bar }.by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+              .or change { Foo.baz }.by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          end
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense when the argument to `by` is zero ' \
+         'with compound expectations by `|`' do
+        expect_offense(<<~RUBY)
+          it do
+            expect { foo }
+              .to change(Foo, :bar).by(0) |
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                  change(Foo, :baz).by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+            expect { foo }
+              .to change { Foo.bar }.by(0) |
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+                  change { Foo.baz }.by(0)
+                  ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer negated matchers with compound expectations over `change.by(0)`.
+          end
+        RUBY
+
+        expect_no_corrections
+      end
+    end
+  end
+
+  context "with `NegatedMatcher: 'not_change'`" do
+    let(:cop_config) { { 'NegatedMatcher' => 'not_change' } }
+
+    it 'registers an offense and autocorrect when ' \
+       'the argument to `by` is zero with compound expectations' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }.to change(Foo, :bar).by(0).and change(Foo, :baz).by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+                                                        ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+          expect { foo }.to change { Foo.bar }.by(0).and change { Foo.baz }.by(0)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+                                                         ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { foo }.to not_change(Foo, :bar).and not_change(Foo, :baz)
+          expect { foo }.to not_change { Foo.bar }.and not_change { Foo.baz }
+        end
+      RUBY
+    end
+
+    it 'registers an offense and autocorrect when ' \
+       'the argument to `by` is zero with compound expectations ' \
+       'with line break' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }
+            .to change(Foo, :bar).by(0)
+                ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .and change(Foo, :baz).by(0)
+                 ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+          expect { foo }
+            .to change { Foo.bar }.by(0)
+                ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .and change { Foo.baz }.by(0)
+                 ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+          expect { foo }
+            .to change(Foo, :bar)
+            .and change(Foo, :baz).by(0)
+                 ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+          expect { foo }
+            .to change { Foo.bar }
+            .and change { Foo.baz }.by(0)
+                 ^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { foo }
+            .to not_change(Foo, :bar)
+            .and not_change(Foo, :baz)
+          expect { foo }
+            .to not_change { Foo.bar }
+            .and not_change { Foo.baz }
+          expect { foo }
+            .to change(Foo, :bar)
+            .and not_change(Foo, :baz)
+          expect { foo }
+            .to change { Foo.bar }
+            .and not_change { Foo.baz }
+        end
+      RUBY
+    end
+
+    it 'registers an offense and autocorrect when ' \
+       'the argument to `by` is zero with compound expectations (`and`/`or`) ' \
+       'with line break before `.by(0)`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }
+            .to change(Foo, :bar)
+                ^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+            .and change(Foo, :baz)
+                 ^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+          expect { foo }
+            .to change { Foo.bar }
+                ^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+            .or change { Foo.baz }
+                ^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { foo }
+            .to not_change(Foo, :bar)
+            .and not_change(Foo, :baz)
+          expect { foo }
+            .to not_change { Foo.bar }
+            .or not_change { Foo.baz }
+        end
+      RUBY
+    end
+
+    it 'registers an offense and autocorrect when ' \
+       'the argument to `by` is zero with compound expectations (`&`/`|`) ' \
+       'with line break before `.by(0)`' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { foo }
+            .to change(Foo, :bar)
+                ^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0) &
+            change(Foo, :baz)
+            ^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+          expect { foo }
+            .to change { Foo.bar }
+                ^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0) |
+            change { Foo.baz }
+            ^^^^^^^^^^^^^^^^^^ Prefer `not_change` with compound expectations over `change.by(0)`.
+            .by(0)
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { foo }
+            .to not_change(Foo, :bar) &
+            not_change(Foo, :baz)
+          expect { foo }
+            .to not_change { Foo.bar } |
+            not_change { Foo.baz }
+        end
+      RUBY
+    end
+  end
+
+  it 'does not register an offense when the argument to `by` is not zero' do
+    expect_no_offenses(<<~RUBY)
+      it do
+        expect { foo }.to change(Foo, :bar).by(1)
+        expect { foo }.to change { Foo.bar }.by(1)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when without expect block' do
+    expect_no_offenses(<<~RUBY)
+      it do
+        change(foo, :bar).by(0)
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/class_check_spec.rb b/spec/rubocop/cop/rspec/class_check_spec.rb
new file mode 100644
index 000000000..1961ca4b9
--- /dev/null
+++ b/spec/rubocop/cop/rspec/class_check_spec.rb
@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ClassCheck do
+  context 'when EnforcedStyle is `be_a`' do
+    context 'when `be_a` is used' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          expect(a).to be_a(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_an` is used' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          expect(a).to be_an(b)
+        RUBY
+      end
+    end
+
+    context 'when `Foo.be_kind_of` is used' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          Foo.be_kind_of(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_kind_of` is used' do
+      it 'registers and corrects an offense' do
+        expect_offense(<<~RUBY)
+          expect(a).to be_kind_of(b)
+                       ^^^^^^^^^^ Prefer `be_a` over `be_kind_of`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(a).to be_a(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_a_kind_of` is used' do
+      it 'registers and corrects an offense' do
+        expect_offense(<<~RUBY)
+          expect(a).to be_a_kind_of(b)
+                       ^^^^^^^^^^^^ Prefer `be_a` over `be_a_kind_of`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(a).to be_a(b)
+        RUBY
+      end
+    end
+  end
+
+  context 'when EnforcedStyle is `be_kind_of`' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'be_kind_of' }
+    end
+
+    context 'when `be_kind_of` is used' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          expect(a).to be_kind_of(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_a_kind_of` is used' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          expect(a).to be_a_kind_of(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_a` is used' do
+      it 'registers and corrects an offense' do
+        expect_offense(<<~RUBY)
+          expect(a).to be_a(b)
+                       ^^^^ Prefer `be_kind_of` over `be_a`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(a).to be_kind_of(b)
+        RUBY
+      end
+    end
+
+    context 'when `be_an` is used' do
+      it 'registers and corrects an offense' do
+        expect_offense(<<~RUBY)
+          expect(a).to be_an(b)
+                       ^^^^^ Prefer `be_kind_of` over `be_an`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(a).to be_kind_of(b)
+        RUBY
+      end
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/contain_exactly_spec.rb b/spec/rubocop/cop/rspec/contain_exactly_spec.rb
new file mode 100644
index 000000000..a55b25124
--- /dev/null
+++ b/spec/rubocop/cop/rspec/contain_exactly_spec.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ContainExactly do
+  it 'flags `contain_exactly` with only splat arguments' do
+    expect_offense(<<~RUBY)
+      it { is_expected.to contain_exactly(*array1, *array2) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `match_array` when matching array values.
+      it { is_expected.to contain_exactly(*[1,2,3]) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `match_array` when matching array values.
+      it { is_expected.to contain_exactly(*a.merge(b)) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `match_array` when matching array values.
+      it { is_expected.to contain_exactly(*(a + b)) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `match_array` when matching array values.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { is_expected.to match_array(array1 + array2) }
+      it { is_expected.to match_array([1,2,3]) }
+      it { is_expected.to match_array(a.merge(b)) }
+      it { is_expected.to match_array((a + b)) }
+    RUBY
+  end
+
+  it 'flags `contain_exactly` with a splatted percent literal array' do
+    expect_offense(<<~RUBY)
+      it { is_expected.to contain_exactly(*%w(a b)) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `match_array` when matching array values.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { is_expected.to match_array(%w(a b)) }
+    RUBY
+  end
+
+  it 'does not flag `match_array`' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to match_array(array1 + array2) }
+    RUBY
+  end
+
+  it 'does not flag `contain_exactly` with mixed arguments' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to contain_exactly(content, *array) }
+      it { is_expected.to contain_exactly(*array, content) }
+    RUBY
+  end
+
+  # Don't do the work of RSpec/BeEmpty
+  it 'does not flag `contain_exactly` with no arguments' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to contain_exactly }
+      it { is_expected.to contain_exactly() }
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/context_method_spec.rb b/spec/rubocop/cop/rspec/context_method_spec.rb
index efc8bf33f..6c730835e 100644
--- a/spec/rubocop/cop/rspec/context_method_spec.rb
+++ b/spec/rubocop/cop/rspec/context_method_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ContextMethod do
-  subject(:cop) { described_class.new }
-
   it 'ignores describe blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe '.foo_bar' do
       end
 
@@ -13,29 +11,51 @@
     RUBY
   end
 
+  it 'ignores context without `.` or `#` at the beginning' do
+    expect_no_offenses(<<~RUBY)
+      context "when it's sunny" do
+      end
+    RUBY
+  end
+
   it 'flags context with `.` at the beginning' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context '.foo_bar' do
               ^^^^^^^^^^ Use `describe` for testing methods.
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe '.foo_bar' do
       end
     RUBY
   end
 
   it 'flags context with `#` at the beginning' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context '#foo_bar' do
               ^^^^^^^^^^ Use `describe` for testing methods.
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe '#foo_bar' do
       end
     RUBY
   end
+
+  it 'flags multi-line context with `#` at the beginning' do
+    expect_offense(<<~'RUBY')
+      context '#foo_bar' \
+              ^^^^^^^^^^^^ Use `describe` for testing methods.
+              '.baz'do
+      end
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      describe '#foo_bar' \
+              '.baz'do
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/context_wording_spec.rb b/spec/rubocop/cop/rspec/context_wording_spec.rb
index 53979c05d..8820e1038 100644
--- a/spec/rubocop/cop/rspec/context_wording_spec.rb
+++ b/spec/rubocop/cop/rspec/context_wording_spec.rb
@@ -1,53 +1,77 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ContextWording, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'Prefixes' => %w[when with] } }
+RSpec.describe RuboCop::Cop::RSpec::ContextWording do
+  let(:cop_config) do
+    { 'Prefixes' => %w[when with without], 'AllowedPatterns' => [] }
+  end
 
   it 'skips describe blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'the display name not present' do
       end
     RUBY
   end
 
   it 'finds context without `when` at the beginning' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~'RUBY')
       context 'the display name not present' do
-              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
+      end
+    RUBY
+  end
+
+  it 'finds context without `when` at the beginning and contains `#{}`' do
+    expect_offense(<<~'RUBY')
+      context "the #{display} name not present" do
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
+      end
+    RUBY
+  end
+
+  it 'finds context without `when` at the beginning ' \
+     'and command surrounded by back ticks' do
+    expect_offense(<<~'RUBY')
+      context `pwd` do
+              ^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
       end
     RUBY
   end
 
   it 'finds shared_context without `when` at the beginning' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~'RUBY')
       shared_context 'the display name not present' do
-                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
       end
     RUBY
   end
 
   it "skips descriptions beginning with 'when'" do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context 'when the display name is not present' do
       end
     RUBY
   end
 
+  it "skips descriptions beginning with 'when,'" do
+    expect_no_offenses(<<~RUBY)
+      context 'when, for some inexplicable reason, you inject a subordinate clause' do
+      end
+    RUBY
+  end
+
   it 'finds context without separate `when` at the beginning' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~'RUBY')
       context 'whenever you do' do
-              ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+              ^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
       end
     RUBY
   end
 
   context 'with metadata hash' do
     it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~'RUBY')
         context 'whenever you do', legend: true do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+                ^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
         end
       RUBY
     end
@@ -55,9 +79,9 @@
 
   context 'with symbol metadata' do
     it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~'RUBY')
         context 'whenever you do', :legend do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+                ^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
         end
       RUBY
     end
@@ -65,30 +89,177 @@
 
   context 'with mixed metadata' do
     it 'finds context without separate `when` at the beginning' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~'RUBY')
         context 'whenever you do', :legend, myth: true do
-                ^^^^^^^^^^^^^^^^^ Start context description with 'when', or 'with'.
+                ^^^^^^^^^^^^^^^^^ Context description should match /^when\b/, /^with\b/, or /^without\b/.
         end
       RUBY
     end
   end
 
   context 'when configured' do
-    let(:cop_config) { { 'Prefixes' => %w[if] } }
+    let(:cop_config) { { 'Prefixes' => %w[if], 'AllowedPatterns' => [] } }
 
     it 'finds context without allowed prefixes at the beginning' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~'RUBY')
         context 'when display name is present' do
-                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Start context description with 'if'.
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /^if\b/.
         end
       RUBY
     end
 
     it 'skips descriptions with allowed prefixes at the beginning' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         context 'if display name is present' do
         end
       RUBY
     end
+
+    context 'with a multi-word prefix' do
+      let(:cop_config) do
+        { 'Prefixes' => ['assuming that'], 'AllowedPatterns' => [] }
+      end
+
+      it 'skips descriptions with allowed multi-word prefixes' do
+        expect_no_offenses(<<~RUBY)
+          context 'assuming that display name is present' do
+          end
+        RUBY
+      end
+    end
+
+    context 'with special regex characters' do
+      let(:cop_config) { { 'Prefixes' => ['a$b\d'], 'AllowedPatterns' => [] } }
+
+      it 'matches the full prefix' do
+        expect_offense(<<~'RUBY')
+          context 'a' do
+                  ^^^ Context description should match /^a\$b\\d\b/.
+          end
+        RUBY
+      end
+
+      it 'matches special characters' do
+        expect_no_offenses(<<~'RUBY')
+          context 'a$b\d something' do
+          end
+        RUBY
+      end
+    end
+
+    context 'when `AllowedPatterns: [とき$]`' do
+      let(:cop_config) do
+        { 'Prefixes' => [], 'AllowedPatterns' => ['とき$'] }
+      end
+
+      it 'finds context without `とき` at the ending' do
+        expect_offense(<<~RUBY)
+          context '条件を満たす' do
+                  ^^^^^^^^ Context description should match /とき$/.
+          end
+        RUBY
+      end
+
+      it 'finds shared_context without `とき` at the ending' do
+        expect_offense(<<~RUBY)
+          shared_context '条件を満たす' do
+                         ^^^^^^^^ Context description should match /とき$/.
+          end
+        RUBY
+      end
+
+      it "skips descriptions ending with 'とき'" do
+        expect_no_offenses(<<~RUBY)
+          context '条件を満たすとき' do
+          end
+        RUBY
+      end
+    end
+
+    context 'when `Prefixes: [when]` and `AllowedPatterns: [patterns]`' do
+      let(:cop_config) do
+        { 'Prefixes' => %w[when], 'AllowedPatterns' => ['patterns'] }
+      end
+
+      it 'finds context without `when` at the beginning and not included ' \
+         '`/patterns/`' do
+        expect_offense(<<~'RUBY')
+          context 'this is an incorrect context' do
+                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /patterns/, or /^when\b/.
+          end
+        RUBY
+      end
+
+      it 'finds shared_context without `when` at the beginning and ' \
+         'not included `/patterns/`' do
+        expect_offense(<<~'RUBY')
+          shared_context 'this is an incorrect context' do
+                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Context description should match /patterns/, or /^when\b/.
+          end
+        RUBY
+      end
+
+      it "skips descriptions beginning with 'when'" do
+        expect_no_offenses(<<~RUBY)
+          context 'when this is valid context' do
+          end
+        RUBY
+      end
+
+      it "skips descriptions include with 'patterns'" do
+        expect_no_offenses(<<~RUBY)
+          context 'this is valid patterns context' do
+          end
+        RUBY
+      end
+    end
+  end
+
+  context 'when `AllowedPatterns:` and `Prefixes:` are both empty' do
+    let(:cop_config) do
+      { 'Prefixes' => [], 'AllowedPatterns' => [] }
+    end
+
+    it 'always registers an offense' do
+      expect_offense(<<~RUBY)
+        context 'this is an incorrect context' do
+                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Current settings will always report an offense. Please add allowed words to `Prefixes` or `AllowedPatterns`.
+        end
+      RUBY
+    end
+  end
+
+  context 'when `Prefixes: [on]' do
+    let(:cop_config) do
+      YAML.safe_load(<<-CONFIG)
+        Prefixes:
+          - on # evaluates to true
+      CONFIG
+    end
+
+    it 'fails' do
+      expect do
+        expect_no_offenses(<<~RUBY)
+          context 'on Linux' do
+          end
+        RUBY
+      end.to raise_error(/Non-string prefixes .+ detected/)
+    end
+  end
+
+  context 'when `Prefixes: ["on"]' do
+    let(:cop_config) do
+      YAML.safe_load(<<-CONFIG)
+        Prefixes:
+          - "on"
+      CONFIG
+    end
+
+    it 'does not fail' do
+      expect { expect_no_offenses(<<~RUBY) }.not_to raise_error
+        context 'on Linux' do
+        end
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/cop_spec.rb b/spec/rubocop/cop/rspec/cop_spec.rb
deleted file mode 100644
index 05260eae8..000000000
--- a/spec/rubocop/cop/rspec/cop_spec.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Cop do
-  subject(:cop) { fake_cop.new(config) }
-
-  let(:config) do
-    rubocop_config =
-      {
-        'AllCops' => {
-          'RSpec' => {
-            'Patterns' => rspec_patterns
-          }
-        },
-        'RSpec/FakeCop' => {
-          'Exclude' => %w[bar_spec.rb]
-        }
-      }
-
-    RuboCop::Config.new(rubocop_config, 'fake_cop_config.yml')
-  end
-
-  let(:fake_cop) do
-    stub_const('RuboCop::RSpec', Module.new)
-    # rubocop:disable Style/ClassAndModuleChildren
-    # rubocop:disable RSpec/LeakyConstantDeclaration
-    class RuboCop::RSpec::FakeCop < described_class
-      def on_send(node)
-        add_offense(node, message: 'I flag everything')
-      end
-    end
-    # rubocop:enable Style/ClassAndModuleChildren
-    # rubocop:enable RSpec/LeakyConstantDeclaration
-    RuboCop::RSpec::FakeCop
-  end
-
-  let(:rspec_patterns) { ['_spec.rb$', '(?:^|/)spec/'] }
-
-  context 'when the source path ends with `_spec.rb`' do
-    it 'registers an offense' do
-      expect_offense(<<-RUBY, 'foo_spec.rb')
-        foo(1)
-        ^^^^^^ I flag everything
-      RUBY
-    end
-
-    it 'ignores the file if it is ignored' do
-      expect_no_offenses(<<-RUBY, 'bar_spec.rb')
-        foo(1)
-      RUBY
-    end
-  end
-
-  context 'when the source path contains `/spec/`' do
-    it 'registers an offense' do
-      expect_offense(<<-RUBY, '/spec/support/thing.rb')
-        foo(1)
-        ^^^^^^ I flag everything
-      RUBY
-    end
-  end
-
-  context 'when the source path starts with `spec/`' do
-    it 'registers an offense' do
-      expect_offense(<<-RUBY, 'spec/support/thing.rb')
-        foo(1)
-        ^^^^^^ I flag everything
-      RUBY
-    end
-  end
-
-  context 'when the file is a source file without "spec" in the name' do
-    it 'ignores the source when the path is not a spec file' do
-      expect_no_offenses(<<-RUBY, 'foo.rb')
-        foo(1)
-      RUBY
-    end
-
-    it 'ignores the source when the path is not a specified pattern' do
-      expect_no_offenses(<<-RUBY, 'foo_test.rb')
-        foo(1)
-      RUBY
-    end
-  end
-
-  context 'when custom patterns are specified' do
-    let(:rspec_patterns) do
-      ['_test\.rb$']
-    end
-
-    it 'registers offenses when the path matches a custom specified pattern' do
-      expect_offense(<<-RUBY, 'foo_test.rb')
-        foo(1)
-        ^^^^^^ I flag everything
-      RUBY
-    end
-  end
-end
diff --git a/spec/rubocop/cop/rspec/describe_class_spec.rb b/spec/rubocop/cop/rspec/describe_class_spec.rb
index 1521c0737..8c4c514e9 100644
--- a/spec/rubocop/cop/rspec/describe_class_spec.rb
+++ b/spec/rubocop/cop/rspec/describe_class_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::DescribeClass do
-  subject(:cop) { described_class.new }
-
   it 'checks first-line describe statements' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe "bad describe" do
                ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
       end
@@ -12,21 +10,21 @@
   end
 
   it 'supports RSpec.describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe Foo do
       end
     RUBY
   end
 
   it 'supports ::RSpec.describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       ::RSpec.describe Foo do
       end
     RUBY
   end
 
   it 'checks describe statements after a require' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       require 'spec_helper'
       describe "bad describe" do
                ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
@@ -35,7 +33,7 @@
   end
 
   it 'checks highlights the first argument of a describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe "bad describe", "blah blah" do
                ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
       end
@@ -43,7 +41,7 @@
   end
 
   it 'ignores nested describe statements' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Some::Class do
         describe "bad describe" do
         end
@@ -51,59 +49,77 @@
     RUBY
   end
 
-  it 'ignores request specs' do
-    expect_no_offenses(<<-RUBY)
-      describe 'my new feature', type: :request do
-      end
-    RUBY
-  end
-
-  it 'ignores feature specs' do
-    expect_no_offenses(<<-RUBY)
-      describe 'my new feature', type: :feature do
-      end
-    RUBY
-  end
-
-  it 'ignores system specs' do
-    expect_no_offenses(<<-RUBY)
-      describe 'my new system test', type: :system do
-      end
-    RUBY
-  end
+  context 'when argument is a String literal' do
+    it 'ignores class without namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Thing' do
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
 
-  it 'ignores feature specs when RSpec.describe is used' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe 'my new feature', type: :feature do
-      end
-    RUBY
-  end
+    it 'ignores class with namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Some::Thing' do
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
 
-  it 'flags specs with non :type metadata' do
-    expect_offense(<<-RUBY)
-      describe 'my new feature', foo: :feature do
-               ^^^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
+    it 'ignores value constants' do
+      expect_no_offenses(<<~RUBY)
+        describe 'VERSION' do
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
 
-  it 'flags normal metadata in describe' do
-    expect_offense(<<-RUBY)
-      describe 'my new feature', blah, type: :wow do
-               ^^^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
-      end
-    RUBY
-  end
+    it 'ignores value constants with namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Some::VERSION' do
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
 
-  it 'ignores feature specs - also with complex options' do
-    expect_no_offenses(<<-RUBY)
-      describe 'my new feature', :test, :type => :feature, :foo => :bar do
-      end
-    RUBY
+    it 'ignores top-level constants with `::` at start' do
+      expect_no_offenses(<<~RUBY)
+        describe '::Some::VERSION' do
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
+
+    it 'checks `camelCase`' do
+      expect_offense(<<~RUBY)
+        describe 'activeRecord' do
+                 ^^^^^^^^^^^^^^ The first argument to describe should be the class or module being tested.
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
+
+    it 'checks numbers at start' do
+      expect_offense(<<~RUBY)
+        describe '2Thing' do
+                 ^^^^^^^^ The first argument to describe should be the class or module being tested.
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
+
+    it 'checks empty strings' do
+      expect_offense(<<~RUBY)
+        describe '' do
+                 ^^ The first argument to describe should be the class or module being tested.
+          subject { Object.const_get(self.class.description) }
+        end
+      RUBY
+    end
   end
 
   it 'ignores an empty describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe do
       end
 
@@ -112,26 +128,8 @@
     RUBY
   end
 
-  it 'ignores routing specs' do
-    expect_no_offenses(<<-RUBY)
-      describe 'my new route', type: :routing do
-      end
-    RUBY
-  end
-
-  it 'ignores view specs' do
-    expect_no_offenses(<<-RUBY)
-      describe 'widgets/index', type: :view do
-      end
-    RUBY
-  end
-
-  it "doesn't blow up on single-line describes" do
-    expect_no_offenses('describe Some::Class')
-  end
-
   it "doesn't flag top level describe in a shared example" do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       shared_examples 'Common::Interface' do
         describe '#public_interface' do
           it 'conforms to interface' do
@@ -143,7 +141,7 @@
   end
 
   it "doesn't flag top level describe in a shared context" do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.shared_context 'Common::Interface' do
         describe '#public_interface' do
           it 'conforms to interface' do
@@ -155,7 +153,7 @@
   end
 
   it "doesn't flag top level describe in an unnamed shared context" do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       shared_context do
         describe '#public_interface' do
           it 'conforms to interface' do
@@ -165,4 +163,56 @@
       end
     RUBY
   end
+
+  it 'ignores `type` metadata ignored by default' do
+    expect_no_offenses(<<~RUBY)
+      describe 'widgets/index', type: :view do
+      end
+    RUBY
+  end
+
+  it 'flags specs with non `type` metadata' do
+    expect_offense(<<~RUBY)
+      describe 'foo bar', foo: :bar do
+               ^^^^^^^^^ The first argument to describe should be the class or module being tested.
+      end
+    RUBY
+  end
+
+  it 'ignores feature specs - also with complex options' do
+    expect_no_offenses(<<~RUBY)
+      describe 'my new feature', :test, foo: :bar, type: :feature do
+      end
+    RUBY
+  end
+
+  it 'flags non-ignored `type` metadata' do
+    expect_offense(<<~RUBY)
+      describe 'wow', blah, type: :wow do
+               ^^^^^ The first argument to describe should be the class or module being tested.
+      end
+    RUBY
+  end
+
+  context 'when IgnoredMetadata is configured' do
+    let(:cop_config) do
+      { 'IgnoredMetadata' =>
+        { 'foo' => ['bar'],
+          'type' => ['wow'] } }
+    end
+
+    it 'ignores configured metadata' do
+      expect_no_offenses(<<~RUBY)
+        describe 'foo bar', foo: :bar do
+        end
+      RUBY
+    end
+
+    it 'ignores configured `type` metadata' do
+      expect_no_offenses(<<~RUBY)
+        describe 'my new system test', type: :wow do
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/describe_method_spec.rb b/spec/rubocop/cop/rspec/describe_method_spec.rb
index bf03acbc3..526bd70d5 100644
--- a/spec/rubocop/cop/rspec/describe_method_spec.rb
+++ b/spec/rubocop/cop/rspec/describe_method_spec.rb
@@ -1,22 +1,29 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::DescribeMethod do
-  subject(:cop) { described_class.new }
-
   it 'ignores describes with only a class' do
     expect_no_offenses('describe Some::Class do; end')
   end
 
   it 'enforces non-method names' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Some::Class, 'nope', '.incorrect_usage' do
                             ^^^^^^ The second argument to describe should be the method being tested. '#instance' or '.class'.
       end
     RUBY
   end
 
+  it 'enforces non-method names with multi-line describe' do
+    expect_offense(<<~'RUBY')
+      describe Some::Class, "foo" \
+                            ^^^^^^^ The second argument to describe should be the method being tested. '#instance' or '.class'.
+        "bar" do
+      end
+    RUBY
+  end
+
   it 'skips methods starting with a . or #' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Some::Class, '.asdf' do
       end
 
@@ -25,8 +32,20 @@
     RUBY
   end
 
+  it 'skips methods starting with a . or # with multi-line describe' do
+    expect_no_offenses(<<~'RUBY')
+      describe Some::Class, ".foo" \
+        "bar" do
+      end
+
+      describe Some::Class, "#foo" \
+        "bar" do
+      end
+    RUBY
+  end
+
   it 'skips specs not having a string second argument' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Some::Class, :config do
       end
     RUBY
diff --git a/spec/rubocop/cop/rspec/describe_symbol_spec.rb b/spec/rubocop/cop/rspec/describe_symbol_spec.rb
index ced37c112..f9b23f694 100644
--- a/spec/rubocop/cop/rspec/describe_symbol_spec.rb
+++ b/spec/rubocop/cop/rspec/describe_symbol_spec.rb
@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::DescribeSymbol do
-  subject(:cop) { described_class.new }
-
-  it 'flags violations for `describe :symbol`' do
-    expect_offense(<<-RUBY)
+  it 'flags offenses for `describe :symbol`' do
+    expect_offense(<<~RUBY)
       describe(:some_method) { }
                ^^^^^^^^^^^^ Avoid describing symbols.
     RUBY
   end
 
-  it 'flags violations for `describe :symbol` with multiple arguments' do
-    expect_offense(<<-RUBY)
+  it 'flags offenses for `describe :symbol` with multiple arguments' do
+    expect_offense(<<~RUBY)
       describe(:some_method, "description") { }
                ^^^^^^^^^^^^ Avoid describing symbols.
     RUBY
   end
 
-  it 'flags violations for `RSpec.describe :symbol`' do
-    expect_offense(<<-RUBY)
+  it 'flags offenses for `RSpec.describe :symbol`' do
+    expect_offense(<<~RUBY)
       RSpec.describe(:some_method, "description") { }
                      ^^^^^^^^^^^^ Avoid describing symbols.
     RUBY
   end
 
-  it 'flags violations for a nested `describe`' do
-    expect_offense(<<-RUBY)
+  it 'flags offenses for a nested `describe`' do
+    expect_offense(<<~RUBY)
       RSpec.describe Foo do
         describe :to_s do
                  ^^^^^ Avoid describing symbols.
diff --git a/spec/rubocop/cop/rspec/described_class_module_wrapping_spec.rb b/spec/rubocop/cop/rspec/described_class_module_wrapping_spec.rb
index fd2cad7d0..914d0b472 100644
--- a/spec/rubocop/cop/rspec/described_class_module_wrapping_spec.rb
+++ b/spec/rubocop/cop/rspec/described_class_module_wrapping_spec.rb
@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::DescribedClassModuleWrapping do
-  subject(:cop) { described_class.new }
-
+RSpec.describe RuboCop::Cop::RSpec::DescribedClassModuleWrapping, :ruby27 do
   it 'allows a describe block in the outermost scope' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe MyClass do
         subject { "MyClass" }
       end
     RUBY
   end
 
-  it 'registers an offense when RSpec.describe is nested within a module' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense when RSpec.describe block is nested ' \
+     'within a module' do
+    expect_offense(<<~RUBY)
       module MyModule
       ^^^^^^^^^^^^^^^ Avoid opening modules and defining specs within them.
         RSpec.describe MyClass do
@@ -23,8 +22,22 @@ module MyModule
     RUBY
   end
 
-  it 'registers an offense when RSpec.describe is nested within two modules' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense when RSpec.describe numblock is nested ' \
+     'within a module' do
+    expect_offense(<<~RUBY)
+      module MyModule
+      ^^^^^^^^^^^^^^^ Avoid opening modules and defining specs within them.
+        RSpec.describe MyClass do
+          _1
+          subject { "MyClass" }
+        end
+      end
+    RUBY
+  end
+
+  it 'registers an offense when RSpec.describe block is nested ' \
+     'within two modules' do
+    expect_offense(<<~RUBY)
       module MyFirstModule
       ^^^^^^^^^^^^^^^^^^^^ Avoid opening modules and defining specs within them.
         module MySecondModule
@@ -38,8 +51,8 @@ module MySecondModule
     RUBY
   end
 
-  it 'allows a module that does not contain RSpec.describe' do
-    expect_no_offenses(<<-RUBY)
+  it 'allows a module that does not contain RSpec.describe block' do
+    expect_no_offenses(<<~RUBY)
       module MyModule
         def some_method
         end
diff --git a/spec/rubocop/cop/rspec/described_class_spec.rb b/spec/rubocop/cop/rspec/described_class_spec.rb
index 95d0895b3..c8b1c5ed4 100644
--- a/spec/rubocop/cop/rspec/described_class_spec.rb
+++ b/spec/rubocop/cop/rspec/described_class_spec.rb
@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::DescribedClass, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::DescribedClass do
   let(:cop_config) { {} }
 
   context 'when SkipBlocks is `true`' do
     let(:cop_config) { { 'SkipBlocks' => true } }
 
-    it 'ignores violations within non-rspec blocks' do
-      expect_offense(<<-RUBY)
+    it 'ignores offenses within non-rspec blocks' do
+      expect_offense(<<~RUBY)
         describe MyClass do
           controller(ApplicationController) do
-            bar = MyClass
+            self.bar = MyClass
           end
 
           before do
@@ -25,12 +23,49 @@
           end
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        describe MyClass do
+          controller(ApplicationController) do
+            self.bar = MyClass
+          end
+
+          before do
+            described_class
+
+            Foo.custom_block do
+              MyClass
+            end
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores offenses within non-rspec numblocks' do
+      expect_offense(<<~RUBY)
+        describe MyClass do
+          controller(ApplicationController) do
+            do_some_work(_1)
+            self.bar = MyClass
+          end
+
+          before do
+            MyClass
+            ^^^^^^^ Use `described_class` instead of `MyClass`.
+
+            Foo.custom_block do
+              do_some_work(_1)
+              MyClass
+            end
+          end
+        end
+      RUBY
     end
   end
 
   context 'when SkipBlocks is `false`' do
-    it 'flags violations within all blocks' do
-      expect_offense(<<-RUBY)
+    it 'flags offenses within all blocks' do
+      expect_offense(<<~RUBY)
         describe MyClass do
           controller(ApplicationController) do
             bar = MyClass
@@ -48,6 +83,22 @@
           end
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        describe MyClass do
+          controller(ApplicationController) do
+            bar = described_class
+          end
+
+          before do
+            described_class
+
+            Foo.custom_block do
+              described_class
+            end
+          end
+        end
+      RUBY
     end
   end
 
@@ -55,7 +106,7 @@
     let(:cop_config) { { 'EnforcedStyle' => :described_class } }
 
     it 'flags for the use of the described class' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass do
           include MyClass
                   ^^^^^^^ Use `described_class` instead of `MyClass`.
@@ -68,7 +119,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         describe MyClass do
           include described_class
 
@@ -79,17 +130,34 @@
       RUBY
     end
 
+    it 'allows accessing constants from variables when in a nested namespace' do
+      expect_no_offenses(<<~RUBY)
+        module Foo
+          describe MyClass do
+            let(:foo) { SomeClass }
+            let(:baz) { foo::CONST }
+          end
+        end
+      RUBY
+    end
+
     it 'flags with metadata' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass, some: :metadata do
           subject { MyClass }
                     ^^^^^^^ Use `described_class` instead of `MyClass`.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        describe MyClass, some: :metadata do
+          subject { described_class }
+        end
+      RUBY
     end
 
     it 'ignores described class as string' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyClass do
           subject { "MyClass" }
         end
@@ -97,7 +165,7 @@
     end
 
     it 'ignores describe that do not reference to a class' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe "MyClass" do
           subject { "MyClass" }
         end
@@ -105,7 +173,7 @@
     end
 
     it 'ignores class if the scope is changing' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyClass do
           Class.new  { foo = MyClass }
           Module.new { bar = MyClass }
@@ -127,7 +195,7 @@ module MyModule
     end
 
     it 'takes class from innermost describe' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass do
           describe MyClass::Foo do
             subject { MyClass::Foo }
@@ -137,18 +205,20 @@ module MyModule
           end
         end
       RUBY
-    end
 
-    it 'ignores subclasses' do
-      expect_no_offenses(<<-RUBY)
+      expect_correction(<<~RUBY)
         describe MyClass do
-          subject { MyClass::SubClass }
+          describe MyClass::Foo do
+            subject { described_class }
+
+            let(:foo) { MyClass }
+          end
         end
       RUBY
     end
 
     it 'ignores non-matching namespace defined on `describe` level' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyNamespace::MyClass do
           subject { ::MyClass }
           let(:foo) { MyClass }
@@ -157,7 +227,7 @@ module MyModule
     end
 
     it 'ignores non-matching namespace' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         module MyNamespace
           describe MyClass do
             subject { ::MyClass }
@@ -167,16 +237,22 @@ module MyNamespace
     end
 
     it 'flags the use of described class with namespace' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyNamespace::MyClass do
           subject { MyNamespace::MyClass }
                     ^^^^^^^^^^^^^^^^^^^^ Use `described_class` instead of `MyNamespace::MyClass`.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        describe MyNamespace::MyClass do
+          subject { described_class }
+        end
+      RUBY
     end
 
     it 'ignores non-matching namespace in usages' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         module UnrelatedNamespace
           describe MyClass do
             subject { MyNamespace::MyClass }
@@ -185,8 +261,8 @@ module UnrelatedNamespace
       RUBY
     end
 
-    it 'ignores violations within a class scope change' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores offenses within a class scope change' do
+      expect_no_offenses(<<~RUBY)
         describe MyNamespace::MyClass do
           before do
             class Foo
@@ -197,8 +273,8 @@ class Foo
       RUBY
     end
 
-    it 'ignores violations within a hook scope change' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores offenses within a hook scope change' do
+      expect_no_offenses(<<~RUBY)
         describe do
           before do
             MyNamespace::MyClass.new
@@ -208,7 +284,7 @@ class Foo
     end
 
     it 'flags the use of described class with module' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         module MyNamespace
           describe MyClass do
             subject { MyNamespace::MyClass }
@@ -217,7 +293,7 @@ module MyNamespace
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         module MyNamespace
           describe MyClass do
             subject { described_class }
@@ -227,7 +303,7 @@ module MyNamespace
     end
 
     it 'flags the use of described class with nested namespace' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         module A
           class B::C
             module D
@@ -247,17 +323,33 @@ module D
           end
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        module A
+          class B::C
+            module D
+              describe E do
+                subject { described_class }
+                let(:one) { described_class }
+                let(:two) { described_class }
+                let(:six) { described_class }
+                let(:ten) { described_class }
+              end
+            end
+          end
+        end
+      RUBY
     end
 
     it 'accepts an empty block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyClass do
         end
       RUBY
     end
 
     it 'ignores if a local variable is part of the namespace' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Broken do
           [Foo, Bar].each do |klass|
             describe klass::Baz.name do
@@ -269,7 +361,7 @@ module D
     end
 
     it 'ignores if `described_class` is a part of the constant' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         module SomeGem
           describe VERSION do
             it 'returns proper version string' do
@@ -279,13 +371,79 @@ module SomeGem
         end
       RUBY
     end
+
+    context 'when OnlyStaticConstants is `true`' do
+      let(:cop_config) do
+        { 'EnforcedStyle' => :described_class, 'OnlyStaticConstants' => true }
+      end
+
+      it 'ignores class with constant' do
+        expect_no_offenses(<<~RUBY)
+          describe MyClass do
+            subject { MyClass::FOO }
+          end
+        RUBY
+      end
+
+      it 'ignores class with subclasses' do
+        expect_no_offenses(<<~RUBY)
+          describe MyClass do
+            subject { MyClass::Subclass }
+          end
+        RUBY
+      end
+    end
+
+    context 'when OnlyStaticConstants is `false`' do
+      let(:cop_config) do
+        { 'EnforcedStyle' => :described_class, 'OnlyStaticConstants' => false }
+      end
+
+      it 'flags class with constant' do
+        expect_offense(<<~RUBY)
+          describe MyClass do
+            subject { MyClass::FOO }
+                      ^^^^^^^ Use `described_class` instead of `MyClass`.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe MyClass do
+            subject { described_class::FOO }
+          end
+        RUBY
+      end
+
+      it 'flags class with subclasses' do
+        expect_offense(<<~RUBY)
+          describe MyClass do
+            subject { MyClass::Subclass }
+                      ^^^^^^^ Use `described_class` instead of `MyClass`.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe MyClass do
+            subject { described_class::Subclass }
+          end
+        RUBY
+      end
+    end
+
+    it 'ignores parenthesized namespaces - begin_types' do
+      expect_no_offenses(<<~RUBY)
+        describe MyClass do
+          subject { (MyNamespace)::MyClass }
+        end
+      RUBY
+    end
   end
 
   context 'when EnforcedStyle is :explicit' do
     let(:cop_config) { { 'EnforcedStyle' => :explicit } }
 
     it 'flags the use of the described_class' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass do
           include described_class
                   ^^^^^^^^^^^^^^^ Use `MyClass` instead of `described_class`.
@@ -298,7 +456,7 @@ module SomeGem
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         describe MyClass do
           include MyClass
 
@@ -310,7 +468,7 @@ module SomeGem
     end
 
     it 'ignores described_class as string' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyClass do
           subject { "described_class" }
         end
@@ -318,15 +476,15 @@ module SomeGem
     end
 
     it 'ignores describe that do not reference to a class' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe "MyClass" do
           subject { described_class }
         end
       RUBY
     end
 
-    it 'ignores violations within a class scope change' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores offenses within a class scope change' do
+      expect_no_offenses(<<~RUBY)
         describe MyNamespace::MyClass do
           before do
             class Foo
@@ -337,8 +495,8 @@ class Foo
       RUBY
     end
 
-    it 'ignores violations within a hook scope change' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores offenses within a hook scope change' do
+      expect_no_offenses(<<~RUBY)
         describe do
           before do
             described_class.new
@@ -348,14 +506,14 @@ class Foo
     end
 
     it 'autocorrects corresponding' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe(Foo) { include described_class }
                                 ^^^^^^^^^^^^^^^ Use `Foo` instead of `described_class`.
         describe(Bar) { include described_class }
                                 ^^^^^^^^^^^^^^^ Use `Bar` instead of `described_class`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         describe(Foo) { include Foo }
         describe(Bar) { include Bar }
       RUBY
diff --git a/spec/rubocop/cop/rspec/dialect_spec.rb b/spec/rubocop/cop/rspec/dialect_spec.rb
index a1fcb2d7e..75ba063d0 100644
--- a/spec/rubocop/cop/rspec/dialect_spec.rb
+++ b/spec/rubocop/cop/rspec/dialect_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::Dialect, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::Dialect do
   let(:cop_config) do
     {
       'PreferredMethods' => {
@@ -12,14 +10,14 @@
   end
 
   it 'allows describe blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'display name presence' do
       end
     RUBY
   end
 
   it 'allows calling methods named context in examples' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'tests common context invocations' do
         expect(request.context).to be_empty?
       end
@@ -27,20 +25,20 @@
   end
 
   it 'registers an offense for context blocks' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context 'display name presence' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `describe` over `context`.
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe 'display name presence' do
       end
     RUBY
   end
 
   it 'registers an offense for RSpec.context blocks' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.context 'context' do
       ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `describe` over `context`.
         it 'tests common context invocations' do
@@ -49,7 +47,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe 'context' do
         it 'tests common context invocations' do
           expect(request.context).to be_empty?
@@ -66,7 +64,7 @@
     end
 
     it 'allows all methods blocks' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         context 'is important' do
           specify 'for someone to work' do
             everyone.should have_some_leeway
diff --git a/spec/rubocop/cop/rspec/duplicated_metadata_spec.rb b/spec/rubocop/cop/rspec/duplicated_metadata_spec.rb
new file mode 100644
index 000000000..dea1d69ea
--- /dev/null
+++ b/spec/rubocop/cop/rspec/duplicated_metadata_spec.rb
@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::DuplicatedMetadata do
+  context 'when metadata is not used' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Something' do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is not duplicated' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Something', :a, :b do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is duplicated on example group' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        describe 'Something', :a, :a do
+                                  ^^ Avoid duplicated metadata.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe 'Something', :a do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is duplicated in different order' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        describe 'Something', :a, :b, :a do
+                                      ^^ Avoid duplicated metadata.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe 'Something', :a, :b do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is duplicated on example' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        it 'does something', :a, :a do
+                                 ^^ Avoid duplicated metadata.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something', :a do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is duplicated on shared examples' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        shared_examples 'something', :a, :a do
+                                         ^^ Avoid duplicated metadata.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        shared_examples 'something', :a do
+        end
+      RUBY
+    end
+  end
+
+  context 'when metadata is duplicated on configuration hook' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.configure do |configuration|
+          configuration.before(:each, :a, :a) do
+                                          ^^ Avoid duplicated metadata.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.configure do |configuration|
+          configuration.before(:each, :a) do
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/empty_example_group_spec.rb b/spec/rubocop/cop/rspec/empty_example_group_spec.rb
index 33fe29670..74016c940 100644
--- a/spec/rubocop/cop/rspec/empty_example_group_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_example_group_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::EmptyExampleGroup, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'flags an empty context' do
-    expect_offense(<<-RUBY)
+RSpec.describe RuboCop::Cop::RSpec::EmptyExampleGroup do
+  it 'flags an empty example group' do
+    expect_offense(<<~RUBY)
       describe Foo do
         context 'when bar' do
         ^^^^^^^^^^^^^^^^^^ Empty example group detected.
@@ -21,18 +19,353 @@
         it { should be_true }
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+
+        describe '#thingy?' do
+          specify do
+            expect(whatever.thingy?).to be(true)
+          end
+        end
+
+        it { should be_true }
+      end
+    RUBY
   end
 
   it 'flags an empty top level describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
       ^^^^^^^^^^^^ Empty example group detected.
       end
     RUBY
+
+    expect_correction('')
+  end
+
+  it 'flags example group with examples defined in hooks' do
+    expect_offense(<<~RUBY)
+      context 'hook with implicit scope' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        before do
+          it { is_expected.to never_run }
+        end
+      end
+
+      context 'hook with explicit scope' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        around(:example) do
+          it { is_expected.to never_run }
+        end
+      end
+
+      context 'hook with explicit scope and metadata' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        after(:each, :corrupt, type: :cop) do
+          it { is_expected.to never_run }
+        end
+      end
+    RUBY
+
+    expect_correction("\n\n")
+  end
+
+  it 'ignores example group with examples defined in `if` branches' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Ruby 2.3 syntax' do
+        version = 2.3
+
+        if RUBY_VERSION >= version
+          it { expect(use_safe_navigation_operator?(code)).to be(true) }
+        else
+          warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples but no examples in `if` branches' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Ruby 2.3 syntax' do
+        version = 2.3
+
+        if RUBY_VERSION < version
+          warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+        end
+
+        it { expect(newspaper(page)).to have_ads }
+      end
+    RUBY
+  end
+
+  it 'flags an empty example group with no examples defined in `if` branches' do
+    expect_offense(<<~RUBY)
+      describe 'Ruby 2.3 syntax' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        version = 2.3
+
+        if RUBY_VERSION >= version
+          warn 'Ruby > 2.3 is supported'
+        else
+          warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+        end
+      end
+
+      describe 'Ruby 2.3 syntax' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        if RUBY_VERSION < 2.3
+        else
+        end
+      end
+
+      describe 'Ruby 2.3 syntax' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        if RUBY_VERSION >= 2.3
+        end
+      end
+    RUBY
+
+    expect_correction("\n\n")
+  end
+
+  it 'ignores example group with examples defined in `case` branches' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        case bar
+        when baz
+          it { expect(result).to be(true) }
+        end
+      end
+
+      describe Foo do
+        case bar
+        when baz
+          it { expect(result).to be(true) }
+        else
+          warn 'Enforce appropriate warnings.'
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples but no examples in `case` branches' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        case bar
+        when baz
+          warn 'Enforce appropriate warnings.'
+        end
+
+        it { expect(result).to have_ads }
+      end
+    RUBY
+  end
+
+  it 'flags an empty example group with no examples defined in `case`' \
+     'branches' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+      ^^^^^^^^^^^^ Empty example group detected.
+        case bar
+        when baz
+          warn 'Enforce appropriate warnings.'
+        else
+          warn 'Enforce appropriate warnings.'
+        end
+      end
+
+      describe Foo do
+      ^^^^^^^^^^^^ Empty example group detected.
+        case bar
+        when baz
+        else
+        end
+      end
+
+      describe Foo do
+      ^^^^^^^^^^^^ Empty example group detected.
+        case bar
+        when baz
+        end
+      end
+    RUBY
+
+    expect_correction("\n\n")
+  end
+
+  it 'ignores example group with examples defined in iterator' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop monthly' do
+        [1, 2, 3].each do |page|
+          it { expect(newspaper(page)).to have_ads }
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in an iterator' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop weekly' do
+        some_method
+        [1, 2, 3].each do |page|
+          it { expect(newspaper(page)).to have_ads }
+        end
+        more_surroundings
+      end
+    RUBY
+  end
+
+  it 'flags example group with no examples defined in an iterator' do
+    expect_offense(<<~RUBY)
+      describe 'RuboCop Sunday' do
+      ^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
+        some_method
+        [1, 2, 3].each do |page|
+          no_examples_here
+          and_no_ads_either
+        end
+        more_surroundings
+      end
+    RUBY
+
+    expect_correction('')
+  end
+
+  it 'ignores example group with examples defined in `if` branch ' \
+     'inside iterator with begin block' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop monthly' do
+        [1, 2, 3].each do |page|
+          version = 2.3
+
+          if RUBY_VERSION >= version
+            it { expect(newspaper(page)).to have_ads }
+          else
+            warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in `if` branch ' \
+     'inside iterator without begin block' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop monthly' do
+        [1, 2, 3].each do |page|
+          if RUBY_VERSION >= 2.3
+            it { expect(newspaper(page)).to have_ads }
+          else
+            warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in nested iterators' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop weekly' do
+        some_method
+        [1, 2, 3].each do |page|
+          [4, 5, 6].each do |index|
+            it { expect(newspaper(page)).to have_ads }
+          end
+        end
+        more_surroundings
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in nested `if` branch' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop monthly' do
+        version = 2.3
+
+        if RUBY_VERSION >= version
+          if RUBY_VERSION <= 3.1
+            it { expect(use_safe_navigation_operator?(code)).to be(true) }
+          else
+            warn 'Ruby > 3.1 is barely supported, please use a newer version for development.'
+          end
+        else
+          warn 'Ruby < 2.3 is barely supported, please use a newer version for development.'
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in an custom block' do
+    expect_no_offenses(<<~RUBY)
+      context 'without arguments' do
+        mute_warnings do
+          it { expect(newspaper(page)).to have_a_lot_of_ads }
+        end
+      end
+
+      context 'with an argument' do
+        with_role :reader do
+          it { expect(newspaper(page)).to have_a_lot_of_ads }
+        end
+      end
+
+      context 'with a block argument' do
+        for_all_species_coming_from(:fish) do |creature|
+          it { expect(newspaper(page)).to have_a_lot_of_ads }
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example group with examples defined in an obscure iterators' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop Friday night' do
+        context 'with each.with_object' do
+          [1, 2, 3].each.with_object(0) do |page, price|
+            it { expect(newspaper(page)).to have_ads }
+          end
+        end
+
+        context 'with each_with_index' do
+          [1, 2, 3].each_with_index do |page, index|
+            it { expect(newspaper(page)).to have_ads }
+          end
+        end
+
+        context 'with map' do
+          [1, 2, 3].map do |page, index|
+            it { expect(newspaper(page)).to have_ads }
+          end
+        end
+
+        context 'with count' do
+          [1, 2, 3].count do |page, index|
+            it { expect(newspaper(page)).to have_ads }
+          end
+        end
+      end
+    RUBY
   end
 
-  it 'does not flag include_examples' do
-    expect_no_offenses(<<-RUBY)
+  it 'ignores example group with examples defined in a nested iterator' do
+    expect_no_offenses(<<~RUBY)
+      describe 'RuboCop daily' do
+        some_method
+        [1, 2, 3].each do |page|
+          some_method
+          [1, 2, 3].each do |paragraph|
+            it { expect(newspaper(page, paragraph)).to have_ads }
+          end
+          more_surroundings
+        end
+        more_surroundings
+      end
+    RUBY
+  end
+
+  it 'ignores examples groups with includes' do
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         context "when something is true" do
           include_examples "some expectations"
@@ -42,15 +375,25 @@
           include_context "some expectations"
         end
 
-        context "when a third thing is true" do
+        context "when the third thing is true" do
           it_behaves_like "some thingy"
         end
+
+        context "when the fourth thing is true" do
+          it_behaves_like "some thingy" do
+            let(:a) { 'foo' }
+          end
+        end
+
+        context "when the fifth thing is true" do
+          it_behaves_like "some thingy", &block
+        end
       end
     RUBY
   end
 
-  it 'does not flag methods matching example group names' do
-    expect_no_offenses(<<-RUBY)
+  it 'ignores methods matching example group names' do
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         it 'yields a block when given' do
           value = nil
@@ -63,25 +406,27 @@
     RUBY
   end
 
-  it 'does not recognize custom include methods by default' do
-    expect_offense(<<-RUBY)
+  it 'flags custom include methods by default' do
+    expect_offense(<<~RUBY)
       describe Foo do
-      ^^^^^^^^^^^^ Empty example group detected.
         context "when I do something clever" do
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Empty example group detected.
           it_has_special_behavior
         end
       end
     RUBY
+
+    expect_correction('')
   end
 
   context 'when a custom include method is specified' do
-    let(:cop_config) do
-      { 'CustomIncludeMethods' => %w[it_has_special_behavior] }
+    before do
+      other_cops.dig('RSpec', 'Language', 'Includes', 'Examples')
+        .push('it_has_special_behavior')
     end
 
-    it 'does not flag an otherwise empty example group' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores an empty example group with a custom include' do
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           context "when I do something clever" do
             it_has_special_behavior
@@ -90,4 +435,71 @@
       RUBY
     end
   end
+
+  it 'ignores example groups with pending examples' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        it 'will be implemented later'
+      end
+
+      describe Foo do
+        it 'will be implemented later', year: 2030
+      end
+
+      describe Foo do
+        pending
+      end
+
+      describe Foo do
+        pending 'too hard to specify'
+      end
+
+      describe Foo do
+        skip
+      end
+
+      describe Foo do
+        skip 'undefined behavior'
+      end
+
+      xdescribe Foo
+
+      describe Foo
+    RUBY
+  end
+
+  it 'ignores example groups defined inside methods' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        def self.with_yaml_loaded(&block)
+          context 'with YAML loaded' do
+            module_exec(&block)
+          end
+        end
+
+        class << self
+          def without_yaml_loaded(&block)
+            context 'without YAML loaded' do
+              module_exec(&block)
+            end
+          end
+        end
+
+        with_yaml_loaded do
+          it_behaves_like 'normal YAML serialization'
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores example groups inside examples' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe 'rspec-core' do
+        it 'runs an example group' do
+          group = RSpec.describe { }
+          group.run
+        end
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/empty_hook_spec.rb b/spec/rubocop/cop/rspec/empty_hook_spec.rb
new file mode 100644
index 000000000..3898c7054
--- /dev/null
+++ b/spec/rubocop/cop/rspec/empty_hook_spec.rb
@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::EmptyHook do
+  context 'with `before` hook' do
+    it 'detects offense for empty `before`' do
+      expect_offense(<<~RUBY)
+        before {}
+        ^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'detects offense for empty `before` with :each scope' do
+      expect_offense(<<~RUBY)
+        before(:each) {}
+        ^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'detects offense for empty `before` with :example scope' do
+      expect_offense(<<~RUBY)
+        before(:example) {}
+        ^^^^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'detects offense for empty `before` with :context scope' do
+      expect_offense(<<~RUBY)
+        before(:context) {}
+        ^^^^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'detects offense for empty `before` with :all scope' do
+      expect_offense(<<~RUBY)
+        before(:all) {}
+        ^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'detects offense for empty `before` with :suite scope' do
+      expect_offense(<<~RUBY)
+        before(:suite) {}
+        ^^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `before` hook' do
+      expect_no_offenses(<<~RUBY)
+        before { create_users }
+      RUBY
+    end
+
+    it 'accepts multiline `before` hook' do
+      expect_no_offenses(<<~RUBY)
+        before(:all) do
+          create_users
+          create_products
+        end
+      RUBY
+    end
+
+    it 'autocorrects `before` with semicolon' do
+      expect_offense(<<~RUBY)
+        before {}; after { clean_up(:foo) }
+        ^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        ; after { clean_up(:foo) }
+      RUBY
+    end
+  end
+
+  context 'with `after` hook' do
+    it 'detects offense for empty `after`' do
+      expect_offense(<<~RUBY)
+        after {}
+        ^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `after` hook' do
+      expect_no_offenses(<<~RUBY)
+        after { cleanup_users }
+      RUBY
+    end
+
+    it 'accepts multiline `after` hook' do
+      expect_no_offenses(<<~RUBY)
+        after(:suite) do
+          cleanup_users
+          cleanup_products
+        end
+      RUBY
+    end
+  end
+
+  context 'with `around` hook' do
+    it 'detects offense for empty `around`' do
+      expect_offense(<<~RUBY)
+        around {}
+        ^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `around` hook' do
+      expect_no_offenses(<<~RUBY)
+        around { yield }
+      RUBY
+    end
+
+    it 'accepts multiline `around` hook' do
+      expect_no_offenses(<<~RUBY)
+        around(:suite) do
+          setup_users
+          yield
+        end
+      RUBY
+    end
+  end
+
+  context 'with `prepend_before` hook' do
+    it 'detects offense for empty `prepend_before`' do
+      expect_offense(<<~RUBY)
+        prepend_before {}
+        ^^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `prepend_before` hook' do
+      expect_no_offenses(<<~RUBY)
+        prepend_before { create_users }
+      RUBY
+    end
+
+    it 'accepts multiline `prepend_before` hook' do
+      expect_no_offenses(<<~RUBY)
+        prepend_before(:all) do
+          create_users
+          create_products
+        end
+      RUBY
+    end
+  end
+
+  context 'with `append_before` hook' do
+    it 'detects offense for empty `append_before`' do
+      expect_offense(<<~RUBY)
+        append_before {}
+        ^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `append_before` hook' do
+      expect_no_offenses(<<~RUBY)
+        append_before { create_users }
+      RUBY
+    end
+
+    it 'accepts multiline `append_before` hook' do
+      expect_no_offenses(<<~RUBY)
+        append_before(:each) do
+          create_users
+          create_products
+        end
+      RUBY
+    end
+  end
+
+  context 'with `prepend_after` hook' do
+    it 'detects offense for empty `prepend_after`' do
+      expect_offense(<<~RUBY)
+        prepend_after {}
+        ^^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `prepend_after` hook' do
+      expect_no_offenses(<<~RUBY)
+        prepend_after { cleanup_users }
+      RUBY
+    end
+
+    it 'accepts multiline `prepend_after` hook' do
+      expect_no_offenses(<<~RUBY)
+        prepend_after(:all) do
+          cleanup_users
+          cleanup_products
+        end
+      RUBY
+    end
+  end
+
+  context 'with `append_after` hook' do
+    it 'detects offense for empty `append_after`' do
+      expect_offense(<<~RUBY)
+        append_after {}
+        ^^^^^^^^^^^^ Empty hook detected.
+      RUBY
+
+      expect_correction("\n")
+    end
+
+    it 'accepts non-empty `append_after` hook' do
+      expect_no_offenses(<<~RUBY)
+        append_after { cleanup_users }
+      RUBY
+    end
+
+    it 'accepts multiline `append_after` hook' do
+      expect_no_offenses(<<~RUBY)
+        append_after(:all) do
+          cleanup_users
+          cleanup_products
+        end
+      RUBY
+    end
+  end
+
+  context 'when the hook is between other blocks' do
+    it 'detects offense for empty `append_after`' do
+      expect_offense(<<~RUBY)
+        let(:foo) { 'bar' }
+
+        before do
+        ^^^^^^ Empty hook detected.
+          # commented out code
+        end
+
+        it do
+          expect(foo).to eq('bar')
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        let(:foo) { 'bar' }
+
+        it do
+          expect(foo).to eq('bar')
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/empty_line_after_example_group_spec.rb b/spec/rubocop/cop/rspec/empty_line_after_example_group_spec.rb
index 486c6501f..16d1c2a12 100644
--- a/spec/rubocop/cop/rspec/empty_line_after_example_group_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_line_after_example_group_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup do
-  subject(:cop) { described_class.new }
-
   it 'checks for empty line after describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe Foo do
         describe '#bar' do
         end
@@ -14,7 +12,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe Foo do
         describe '#bar' do
         end
@@ -26,7 +24,7 @@
   end
 
   it 'highlights single line formulations correctly' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe Foo do
         describe('#bar') { }
         ^^^^^^^^^^^^^^^^^^^^ Add an empty line after `describe`.
@@ -35,7 +33,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe Foo do
         describe('#bar') { }
 
@@ -46,7 +44,7 @@
   end
 
   it 'checks for empty line after context' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.context 'foo' do
         context 'bar' do
         end
@@ -56,7 +54,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.context 'foo' do
         context 'bar' do
         end
@@ -67,8 +65,36 @@
     RUBY
   end
 
+  it 'checks for empty line after shared groups' do
+    expect_offense(<<~RUBY)
+      RSpec.context 'foo' do
+        shared_examples 'bar' do
+        end
+        ^^^ Add an empty line after `shared_examples`.
+        shared_context 'baz' do
+        end
+        ^^^ Add an empty line after `shared_context`.
+        it 'does something' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.context 'foo' do
+        shared_examples 'bar' do
+        end
+
+        shared_context 'baz' do
+        end
+
+        it 'does something' do
+        end
+      end
+    RUBY
+  end
+
   it 'approves empty line after describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe Foo do
         describe '#bar' do
         end
@@ -80,7 +106,7 @@
   end
 
   it 'approves empty line after context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.context 'foo' do
         context 'bar' do
         end
@@ -92,7 +118,7 @@
   end
 
   it 'handles describes in an if block' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       if RUBY_VERSION < 2.3
         describe 'skips checks under old ruby' do
         end
@@ -105,7 +131,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       if RUBY_VERSION < 2.3
         describe 'skips checks under old ruby' do
         end
@@ -118,4 +144,150 @@
       end
     RUBY
   end
+
+  it 'does not register an offense for a comment followed by an empty line' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+        # comment
+
+        describe 'baz' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+        ^^^ Add an empty line after `describe`.
+        # comment
+        describe 'baz' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+
+        # comment
+        describe 'baz' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a multiline comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+        ^^^ Add an empty line after `describe`.
+        # multiline comment
+        # multiline comment
+        describe 'baz' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+
+        # multiline comment
+        # multiline comment
+        describe 'baz' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `describe`.
+        describe 'baz' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+
+        describe 'baz' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+        ^^^ Add an empty line after `describe`.
+        # rubocop:disable RSpec/Foo
+        describe 'baz' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        describe 'bar' do
+        end
+
+        # rubocop:disable RSpec/Foo
+        describe 'baz' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive ' \
+     'when it is followed by a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `describe`.
+        # rubocop:disable RSpec/Foo
+        describe 'baz' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+
+        # rubocop:disable RSpec/Foo
+        describe 'baz' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/empty_line_after_example_spec.rb b/spec/rubocop/cop/rspec/empty_line_after_example_spec.rb
index 98610504f..ca9613cbc 100644
--- a/spec/rubocop/cop/rspec/empty_line_after_example_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_line_after_example_spec.rb
@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterExample, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) { { 'AllowConsecutiveOneLiners' => true } }
-
+RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterExample do
   it 'flags a missing empty line after `it`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe Foo do
         it 'does this' do
         end
@@ -16,7 +12,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe Foo do
         it 'does this' do
         end
@@ -28,7 +24,7 @@
   end
 
   it 'flags one-line examples' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe Foo do
         it { }
         ^^^^^^ Add an empty line after `it`.
@@ -37,7 +33,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe Foo do
         it { }
 
@@ -48,7 +44,7 @@
   end
 
   it 'flags a missing empty line after `specify`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.context 'foo' do
         specify do
         end
@@ -58,7 +54,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.context 'foo' do
         specify do
         end
@@ -70,7 +66,7 @@
   end
 
   it 'ignores when an empty line is present' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe Foo do
         it 'does this' do
         end
@@ -82,7 +78,7 @@
   end
 
   it 'ignores consecutive one-liners' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe Foo do
         it { one }
         it { two }
@@ -91,7 +87,7 @@
   end
 
   it 'flags mixed one-line and multi-line examples' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.context 'foo' do
         it { }
         it { }
@@ -103,19 +99,186 @@
         it { }
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.context 'foo' do
+        it { }
+        it { }
+
+        it 'does this' do
+        end
+
+        it { }
+        it { }
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a comment followed by an empty line' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+        # comment
+
+        it 'does that' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+        ^^^ Add an empty line after `it`.
+        # comment
+        it 'does that' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+
+        # comment
+        it 'does that' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a multiline comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+        ^^^ Add an empty line after `it`.
+        # multiline comment
+        # multiline comment
+        it 'does that' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+
+        # multiline comment
+        # multiline comment
+        it 'does that' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        it 'does this' do
+        end
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `it`.
+        it 'does that' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        it 'does this' do
+        end
+        # rubocop:enable RSpec/Foo
+
+        it 'does that' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+        ^^^ Add an empty line after `it`.
+        # rubocop:disable RSpec/Foo
+        it 'does that' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        it 'does this' do
+        end
+
+        # rubocop:disable RSpec/Foo
+        it 'does that' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive ' \
+     'when it is followed by a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        it 'does this' do
+        end
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `it`.
+        # rubocop:disable RSpec/Foo
+        it 'does that' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        # rubocop:disable RSpec/Foo
+        it 'does this' do
+        end
+        # rubocop:enable RSpec/Foo
+
+        # rubocop:disable RSpec/Foo
+        it 'does that' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
   end
 
   context 'when AllowConsecutiveOneLiners is false' do
     let(:cop_config) { { 'AllowConsecutiveOneLiners' => false } }
 
     it 'ignores consecutive one-liners' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.describe Foo do
           it { one }
           ^^^^^^^^^^ Add an empty line after `it`.
           it { two }
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe Foo do
+          it { one }
+
+          it { two }
+        end
+      RUBY
     end
   end
 end
diff --git a/spec/rubocop/cop/rspec/empty_line_after_final_let_spec.rb b/spec/rubocop/cop/rspec/empty_line_after_final_let_spec.rb
index d43a2fea3..013535893 100644
--- a/spec/rubocop/cop/rspec/empty_line_after_final_let_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_line_after_final_let_spec.rb
@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterFinalLet do
-  subject(:cop) { described_class.new }
-
-  it 'checks for empty line after last let' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for empty line after last let' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
-        ^^^^^^^^^^^^^ Add an empty line after the last `let` block.
+        ^^^^^^^^^^^^^ Add an empty line after the last `let`.
         it { expect(a).to eq(b) }
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
@@ -23,19 +21,19 @@
     RUBY
   end
 
-  it 'check for empty line after the last `let!`' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for empty line after the last `let!`' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let!(:b) do
           b
         end
-        ^^^ Add an empty line after the last `let` block.
+        ^^^ Add an empty line after the last `let!`.
         it { expect(a).to eq(b) }
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let!(:b) do
@@ -47,89 +45,175 @@
     RUBY
   end
 
-  it 'approves empty line after let' do
-    expect_no_offenses(<<-RUBY)
-    RSpec.describe User do
-      let(:a) { a }
-      let(:b) { b }
+  it 'registers an offense for empty line after let with proc argument' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:user, &args[:build_user])
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        it { expect(a).to eq(b) }
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:user, &args[:build_user])
 
-      it { expect(a).to eq(b) }
-    end
+        it { expect(a).to eq(b) }
+      end
     RUBY
   end
 
-  it 'allows comment followed by an empty line after let' do
-    expect_no_offenses(<<-RUBY)
-    RSpec.describe User do
-      let(:a) { a }
-      let(:b) { b }
-      # end of setup
+  it 'does not register an offense for empty line after let' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:b) { b }
 
-      it { expect(a).to eq(b) }
-    end
+        it { expect(a).to eq(b) }
+      end
     RUBY
   end
 
-  it 'flags missing empty line after the comment that comes after last let' do
-    expect_offense(<<-RUBY)
+  it 'does not register an offense for comment ' \
+     'followed by an empty line after let' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
         # end of setup
-        ^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
+
         it { expect(a).to eq(b) }
       end
     RUBY
+  end
 
-    expect_correction(<<-RUBY)
+  it 'flags a missing empty line before a comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:b) { b }
+        ^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        # comment
+        it { expect(a).to eq(b) }
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
-        # end of setup
 
+        # comment
         it { expect(a).to eq(b) }
       end
     RUBY
   end
 
-  it 'flags missing empty line after a multiline comment after last let' do
-    expect_offense(<<-RUBY)
+  it 'flags a missing empty line before a multiline comment' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
-        # a multiline comment marking
-        # the end of setup
-        ^^^^^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
+        ^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        # multiline comment
+        # multiline comment
         it { expect(a).to eq(b) }
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
-        # a multiline comment marking
-        # the end of setup
 
+        # multiline comment
+        # multiline comment
         it { expect(a).to eq(b) }
       end
     RUBY
   end
 
-  it 'ignores empty lines between the lets' do
-    expect_offense(<<-RUBY)
+  it 'flags a missing empty line after a `rubocop:enable` directive' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
+        # rubocop:disable RSpec/Foo
         let(:a) { a }
+        let(:b) { b }
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        it { expect(a).to eq(b) }
+      end
+    RUBY
 
-        subject { described_class }
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        let(:a) { a }
+        let(:b) { b }
+        # rubocop:enable RSpec/Foo
 
-        let!(:b) { b }
-        ^^^^^^^^^^^^^^ Add an empty line after the last `let` block.
         it { expect(a).to eq(b) }
       end
     RUBY
+  end
+
+  it 'flags a missing empty line before a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:b) { b }
+        ^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        # rubocop:disable RSpec/Foo
+        it { expect(a).to eq(b) }
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        let(:b) { b }
+
+        # rubocop:disable RSpec/Foo
+        it { expect(a).to eq(b) }
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive ' \
+     'when it is followed by a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        let(:a) { a }
+        let(:b) { b }
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after the last `let`.
+        # rubocop:disable RSpec/Foo
+        it { expect(a).to eq(b) }
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        let(:a) { a }
+        let(:b) { b }
+        # rubocop:enable RSpec/Foo
+
+        # rubocop:disable RSpec/Foo
+        it { expect(a).to eq(b) }
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
 
-    expect_correction(<<-RUBY)
+  it 'does not register an offense for empty lines between the lets' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
 
@@ -142,8 +226,8 @@
     RUBY
   end
 
-  it 'handles let in tests' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for let in tests' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         # This shouldn't really ever happen in a sane codebase but I still
         # want to avoid false positives
@@ -155,8 +239,8 @@
     RUBY
   end
 
-  it 'handles multiline let block' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for multiline let block' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) do
@@ -168,8 +252,8 @@
     RUBY
   end
 
-  it 'handles let being the latest node' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for let being the latest node' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:b) { b }
@@ -177,8 +261,8 @@
     RUBY
   end
 
-  it 'handles HEREDOC for let' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for HEREDOC for let' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:foo) do
           <<-BAR
@@ -194,8 +278,8 @@
     RUBY
   end
 
-  it 'handles silly HEREDOC syntax for let' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for silly HEREDOC syntax for let' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe 'silly heredoc syntax' do
         let(:foo) { <<-BAR }
         hello
@@ -209,21 +293,21 @@
     RUBY
   end
 
-  it 'handles silly HEREDOC offense' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for silly HEREDOC offense' do
+    expect_offense(<<~RUBY)
       RSpec.describe 'silly heredoc syntax' do
         let(:foo) { <<-BAR }
         hello
         world
         BAR
-        ^^^ Add an empty line after the last `let` block.
+        ^^^ Add an empty line after the last `let`.
         it 'has tricky syntax' do
           expect(foo).to eql("  hello\n  world\n")
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe 'silly heredoc syntax' do
         let(:foo) { <<-BAR }
         hello
diff --git a/spec/rubocop/cop/rspec/empty_line_after_hook_spec.rb b/spec/rubocop/cop/rspec/empty_line_after_hook_spec.rb
index fb4d382ce..49d8bd327 100644
--- a/spec/rubocop/cop/rspec/empty_line_after_hook_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_line_after_hook_spec.rb
@@ -1,133 +1,487 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterHook do
-  subject(:cop) { described_class.new }
-
-  it 'checks for empty line after `before` hook' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        before { do_something }
-        ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
-        it { does_something }
-      end
-    RUBY
+  shared_examples_for 'always require empty line after hook groups' do
+    it 'registers an offense for multiline blocks without empty line before' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          before do
+            do_something
+          end
+          ^^^ Add an empty line after `before`.
+          it { does_something }
+        end
+      RUBY
 
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        before { do_something }
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something_else }
 
-        it { does_something }
-      end
-    RUBY
-  end
+          before do
+            do_something
+          end
 
-  it 'checks for empty line after `after` hook' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        after { do_something }
-        ^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `after`.
-        it { does_something }
-      end
-    RUBY
+          it { does_something }
+        end
+      RUBY
+    end
 
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        after { do_something }
+    it 'registers an offense for empty line after `before` hook' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
+        end
+      RUBY
 
-        it { does_something }
-      end
-    RUBY
-  end
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
 
-  it 'checks for empty line after `around` hook' do
-    expect_offense(<<-RUBY)
-      RSpec.describe User do
-        around { |test| test.run }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `around`.
-        it { does_something }
-      end
-    RUBY
+          it { does_something }
+        end
+      RUBY
+    end
 
-    expect_correction(<<-RUBY)
-      RSpec.describe User do
-        around { |test| test.run }
+    it 'registers an offense for empty line after `after` hook' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          after { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `after`.
+          it { does_something }
+        end
+      RUBY
 
-        it { does_something }
-      end
-    RUBY
-  end
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          after { do_something }
 
-  it 'approves empty line after `before` hook' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        before { do_something }
+          it { does_something }
+        end
+      RUBY
+    end
 
-        it { does_something }
-      end
-    RUBY
-  end
+    it 'registers an offense for empty line after `around` hook' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          around { |test| test.run }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `around`.
+          it { does_something }
+        end
+      RUBY
 
-  it 'approves empty line after `after` hook' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        after { do_something }
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          around { |test| test.run }
 
-        it { does_something }
-      end
-    RUBY
-  end
+          it { does_something }
+        end
+      RUBY
+    end
 
-  it 'approves empty line after `around` hook' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        around { |test| test.run }
+    it 'does not register an offense for empty line after `before` hook' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
 
-        it { does_something }
-      end
-    RUBY
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for empty line after `after` hook' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          after { do_something }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for empty line after `around` hook' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          around { |test| test.run }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for multiline `before` block' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before do
+            do_something
+          end
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for multiline `after` block' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          after do
+            do_something
+          end
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for multiline `around` block' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          around do |test|
+            test.run
+          end
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for `before` being the latest node' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for a comment followed by an empty line' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          # comment
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'flags a missing empty line before a comment' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          # comment
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+
+          # comment
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'flags a missing empty line before a multiline comment' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          # multiline comment
+          # multiline comment
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+
+          # multiline comment
+          # multiline comment
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'flags a missing empty line after a `rubocop:enable` directive' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          # rubocop:disable RSpec/Foo
+          before { do_something }
+          # rubocop:enable RSpec/Foo
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          # rubocop:disable RSpec/Foo
+          before { do_something }
+          # rubocop:enable RSpec/Foo
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'flags a missing empty line before a `rubocop:disable` directive' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          # rubocop:disable RSpec/Foo
+          it { does_something }
+          # rubocop:enable RSpec/Foo
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+
+          # rubocop:disable RSpec/Foo
+          it { does_something }
+          # rubocop:enable RSpec/Foo
+        end
+      RUBY
+    end
+
+    it 'flags a missing empty line after a `rubocop:enable` directive ' \
+       'when it is followed by a `rubocop:disable` directive' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          # rubocop:disable RSpec/Foo
+          before { do_something }
+          # rubocop:enable RSpec/Foo
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          # rubocop:disable RSpec/Foo
+          it { does_something }
+          # rubocop:enable RSpec/Foo
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          # rubocop:disable RSpec/Foo
+          before { do_something }
+          # rubocop:enable RSpec/Foo
+
+          # rubocop:disable RSpec/Foo
+          it { does_something }
+          # rubocop:enable RSpec/Foo
+        end
+      RUBY
+    end
   end
 
-  it 'handles multiline `before` block' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        before do
-          do_something
+  shared_examples_for 'never allows consecutive multiline blocks' do
+    it 'registers an offense for multiline blocks without empty line after' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before do
+            do_something
+          end
+          ^^^ Add an empty line after `before`.
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
         end
+      RUBY
 
-        it { does_something }
-      end
-    RUBY
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before do
+            do_something
+          end
+
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
   end
 
-  it 'handles multiline `after` block' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        after do
-          do_something
+  context 'when AllowConsecutiveOneLiners option has default value `true`' do
+    it_behaves_like 'always require empty line after hook groups'
+    it_behaves_like 'never allows consecutive multiline blocks'
+
+    it 'allows multiple one-liner blocks' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
         end
+      RUBY
 
-        it { does_something }
-      end
-    RUBY
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'allows multiple one-liner blocks with comments' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          # this is a comment
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          # this is a comment
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'does not register an offense for chained one-liner `before` hooks' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'allows chained one-liner with different hooks' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          before { do_something_else }
+          after { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
   end
 
-  it 'handles multiline `around` block' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        around do |test|
-          test.run
+  context 'when AllowConsecutiveOneLiners option `false`' do
+    let(:cop_config) { { 'AllowConsecutiveOneLiners' => false } }
+
+    it_behaves_like 'always require empty line after hook groups'
+    it_behaves_like 'never allows consecutive multiline blocks'
+
+    it 'registers an offense for multiple one-liner same hook blocks' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
         end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'registers an offense for multiple one-liner blocks with comments' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          # this is a comment
+          before { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
 
-        it { does_something }
+          # this is a comment
+          before { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    it 'registers an offense for multiple one-liner different hook blocks' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `before`.
+          after { do_something_else }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `after`.
+          it { does_something }
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          before { do_something }
+
+          after { do_something_else }
+
+          it { does_something }
+        end
+      RUBY
+    end
+
+    context 'when Ruby 2.7', :ruby27 do
+      it 'registers an offense for empty line after `around` hook' do
+        expect_offense(<<~RUBY)
+          RSpec.describe User do
+            around { _1.run }
+            ^^^^^^^^^^^^^^^^^ Add an empty line after `around`.
+            it { does_something }
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          RSpec.describe User do
+            around { _1.run }
+
+            it { does_something }
+          end
+        RUBY
       end
-    RUBY
-  end
 
-  it 'handles `before` being the latest node' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
-        before { do_something }
+      it 'does not register an offense for multiline `around` block' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe User do
+            around do
+              _1.run
+            end
+
+            it { does_something }
+          end
+        RUBY
       end
-    RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/empty_line_after_subject_spec.rb b/spec/rubocop/cop/rspec/empty_line_after_subject_spec.rb
index c4b4132aa..a19239248 100644
--- a/spec/rubocop/cop/rspec/empty_line_after_subject_spec.rb
+++ b/spec/rubocop/cop/rspec/empty_line_after_subject_spec.rb
@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::EmptyLineAfterSubject do
-  subject(:cop) { described_class.new }
-
-  it 'checks for empty line after subject' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for empty line after subject' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add empty line after `subject`.
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
         let(:params) { foo }
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
 
@@ -21,16 +19,23 @@
     RUBY
   end
 
-  it 'checks for empty line after subject!' do
-    expect_offense(<<-RUBY)
+  it 'does not register an offense outside of an example group' do
+    expect_no_offenses(<<~RUBY)
+      subject { foo }
+      bar
+    RUBY
+  end
+
+  it 'registers an offense for empty line after subject!' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject! { described_class.new }
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add empty line after `subject`.
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject!`.
         let(:params) { foo }
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject! { described_class.new }
 
@@ -39,8 +44,8 @@
     RUBY
   end
 
-  it 'approves empty line after subject' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for empty line after subject' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
 
@@ -49,8 +54,8 @@
     RUBY
   end
 
-  it 'approves empty line after subject!' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for empty line after subject!' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         subject! { described_class.new }
 
@@ -59,35 +64,157 @@
     RUBY
   end
 
-  it 'handles subjects in tests' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for multiline subject block' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
-        # This shouldn't really ever happen in a sane codebase but I still
-        # want to avoid false positives
-        it "doesn't mind me calling a method called subject in the test" do
-          subject { bar }
-          let(foo)
+        subject do
+          described_class.new
         end
+
+        let(:params) { foo }
       end
     RUBY
   end
 
-  it 'handles multiline subject block' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for subject being the latest node' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
-        subject do
-          described_class.new
+        subject { described_user }
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a comment followed by an empty line' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+        # comment
+
+        describe 'bar' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
+        # comment
+        describe 'bar' do
         end
+      end
+    RUBY
 
-        let(:params) { foo }
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+
+        # comment
+        describe 'bar' do
+        end
       end
     RUBY
   end
 
-  it 'handles subject being the latest node' do
-    expect_no_offenses(<<-RUBY)
+  it 'flags a missing empty line before a multiline comment' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
+        # multiline comment
+        # multiline comment
+        describe 'bar' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+
+        # multiline comment
+        # multiline comment
+        describe 'bar' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        subject { described_user }
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
+        describe 'bar' do
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
       RSpec.describe User do
+        # rubocop:disable RSpec/Foo
         subject { described_user }
+        # rubocop:enable RSpec/Foo
+
+        describe 'bar' do
+        end
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line before a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe Foo do
+        subject { described_user }
+
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+  end
+
+  it 'flags a missing empty line after a `rubocop:enable` directive ' \
+     'when it is followed by a `rubocop:disable` directive' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        subject { described_user }
+        # rubocop:enable RSpec/Foo
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Add an empty line after `subject`.
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        # rubocop:disable RSpec/Foo
+        subject { described_user }
+        # rubocop:enable RSpec/Foo
+
+        # rubocop:disable RSpec/Foo
+        describe 'bar' do
+        end
+        # rubocop:enable RSpec/Foo
       end
     RUBY
   end
diff --git a/spec/rubocop/cop/rspec/empty_metadata_spec.rb b/spec/rubocop/cop/rspec/empty_metadata_spec.rb
new file mode 100644
index 000000000..8a36b6f85
--- /dev/null
+++ b/spec/rubocop/cop/rspec/empty_metadata_spec.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::EmptyMetadata do
+  context 'without metadata' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Something' do
+        end
+      RUBY
+    end
+  end
+
+  context 'with non-empty metadata hash' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        describe 'Something', { a: b } do
+        end
+      RUBY
+    end
+  end
+
+  context 'with empty metadata hash' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        describe 'Something', {} do
+                              ^^ Avoid empty metadata hash.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe 'Something' do
+        end
+      RUBY
+    end
+  end
+
+  it 'registers no offense for splat kwargs metadata' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Something', **{ a: b } do
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/empty_output_spec.rb b/spec/rubocop/cop/rspec/empty_output_spec.rb
new file mode 100644
index 000000000..d9357a7a2
--- /dev/null
+++ b/spec/rubocop/cop/rspec/empty_output_spec.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::EmptyOutput, :config do
+  it 'registers an offense when using `#output` with an empty string' do
+    expect_offense(<<~RUBY)
+      expect { foo }.to output('').to_stderr
+                        ^^^^^^^^^^ Use `not_to` instead of matching on an empty output.
+      expect { foo }.to output('').to_stdout
+                        ^^^^^^^^^^ Use `not_to` instead of matching on an empty output.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect { foo }.not_to output.to_stderr
+      expect { foo }.not_to output.to_stdout
+    RUBY
+  end
+
+  it 'registers an offense when negatively matching `#output` with ' \
+     'an empty string' do
+    expect_offense(<<~RUBY)
+      expect { foo }.not_to output('').to_stderr
+                            ^^^^^^^^^^ Use `to` instead of matching on an empty output.
+      expect { foo }.to_not output('').to_stdout
+                            ^^^^^^^^^^ Use `to` instead of matching on an empty output.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect { foo }.to output.to_stderr
+      expect { foo }.to output.to_stdout
+    RUBY
+  end
+
+  describe 'compound expectations' do
+    it 'does not register an offense when matching empty strings' do
+      expect_no_offenses(<<~RUBY)
+        expect {
+          :noop
+        }.to output('').to_stdout.and output('').to_stderr
+      RUBY
+    end
+
+    it 'does not register an offense when matching non-empty strings' do
+      expect_no_offenses(<<~RUBY)
+        expect {
+          warn "foo"
+          puts "bar"
+        }.to output("bar\n").to_stdout.and output(/foo/).to_stderr
+      RUBY
+    end
+  end
+
+  it 'does not register an offense when using `#output` with ' \
+     'a non-empty string' do
+    expect_no_offenses(<<~RUBY)
+      expect { foo }.to output('foo').to_stderr
+      expect { foo }.not_to output('foo').to_stderr
+      expect { foo }.to_not output('foo').to_stderr
+    RUBY
+  end
+
+  it 'does not register an offense when using `not_to output`' do
+    expect_no_offenses(<<~RUBY)
+      expect { foo }.not_to output.to_stderr
+      expect { foo }.to_not output.to_stderr
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/eq_spec.rb b/spec/rubocop/cop/rspec/eq_spec.rb
new file mode 100644
index 000000000..1515d72e8
--- /dev/null
+++ b/spec/rubocop/cop/rspec/eq_spec.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::Eq do
+  it 'registers an offense when using `be ==`' do
+    expect_offense(<<~RUBY)
+      it { expect(foo).to be == true }
+                          ^^^^^ Use `eq` instead of `be ==` to compare objects.
+      it { expect(bar).not_to be == 1 }
+                              ^^^^^ Use `eq` instead of `be ==` to compare objects.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { expect(foo).to eq true }
+      it { expect(bar).not_to eq 1 }
+    RUBY
+  end
+
+  it 'does not register an offense when using `eq`' do
+    expect_no_offenses(<<~RUBY)
+      it { expect(foo).to eq true }
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/example_length_spec.rb b/spec/rubocop/cop/rspec/example_length_spec.rb
index b01f88e7f..e9eb9edb7 100644
--- a/spec/rubocop/cop/rspec/example_length_spec.rb
+++ b/spec/rubocop/cop/rspec/example_length_spec.rb
@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ExampleLength, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ExampleLength do
   let(:cop_config) { { 'Max' => 3 } }
 
   it 'ignores non-spec blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       foo do
         line 1
         line 2
@@ -17,14 +15,14 @@
   end
 
   it 'allows an empty example' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it do
       end
     RUBY
   end
 
   it 'allows a short example' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it do
         line 1
         line 2
@@ -34,7 +32,7 @@
   end
 
   it 'ignores comments' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it do
         line 1
         line 2
@@ -46,9 +44,9 @@
 
   context 'when inspecting large examples' do
     it 'flags the example' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
-        ^^^^^ Example has too many lines [4/3].
+        ^^^^^ Example has too many lines. [4/3]
           line 1
           line 2
           line 3
@@ -64,9 +62,9 @@
     end
 
     it 'flags the example' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
-        ^^^^^ Example has too many lines [4/3].
+        ^^^^^ Example has too many lines. [4/3]
           line 1
           line 2
           # comment
@@ -75,4 +73,26 @@
       RUBY
     end
   end
+
+  context 'when `CountAsOne` is not empty' do
+    before { cop_config['CountAsOne'] = ['array'] }
+
+    it 'folds array into one line' do
+      expect_no_offenses(<<~RUBY)
+        it do
+          a = 1
+          a = [
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9
+          ]
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/example_without_description_spec.rb b/spec/rubocop/cop/rspec/example_without_description_spec.rb
index a480ad301..1759505a6 100644
--- a/spec/rubocop/cop/rspec/example_without_description_spec.rb
+++ b/spec/rubocop/cop/rspec/example_without_description_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ExampleWithoutDescription, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ExampleWithoutDescription do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
@@ -10,8 +8,8 @@
   context 'with EnforcedStyle `always_allow`' do
     let(:enforced_style) { 'always_allow' }
 
-    it 'flags empty strings for description' do
-      expect_offense(<<-RUBY)
+    it 'flags `it` with a empty strings for description' do
+      expect_offense(<<~RUBY)
         it '' do
            ^^ Omit the argument when you want to have auto-generated description.
           expect(subject).to be_good
@@ -20,7 +18,7 @@
     end
 
     it 'ignores `it` with a description' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it 'is good' do
           expect(subject).to be_good
         end
@@ -28,19 +26,44 @@
     end
 
     it 'ignores `it` without an argument' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           expect(subject).to be_good
         end
       RUBY
     end
+
+    it 'flags `specify` with a empty strings for description' do
+      expect_offense(<<~RUBY)
+        specify '' do
+                ^^ Omit the argument when you want to have auto-generated description.
+          expect(subject).to be_good
+        end
+      RUBY
+    end
+
+    it 'ignores `specify` without an argument' do
+      expect_no_offenses(<<~RUBY)
+        specify do
+          expect(subject).to be_good
+        end
+      RUBY
+    end
+
+    it 'ignores `specify` with a description' do
+      expect_no_offenses(<<~RUBY)
+        specify 'is good' do
+          expect(subject).to be_good
+        end
+      RUBY
+    end
   end
 
   context 'with EnforcedStyle `single_line_only`' do
     let(:enforced_style) { 'single_line_only' }
 
-    it 'flags missing description in multi-line examples' do
-      expect_offense(<<-RUBY)
+    it 'flags `it` missing description in multi-line examples' do
+      expect_offense(<<~RUBY)
         it do
         ^^ Add a description.
           expect(subject).to be_good
@@ -48,25 +71,46 @@
       RUBY
     end
 
-    it 'ignores missing description in single-line examples' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores `it` missing description in single-line examples' do
+      expect_no_offenses(<<~RUBY)
         it { expect(subject).to be_good }
       RUBY
     end
 
-    it 'flags example with an empty string for description' do
-      expect_offense(<<-RUBY)
+    it 'flags `it` with an empty string for description' do
+      expect_offense(<<~RUBY)
         it('') { expect(subject).to be_good }
            ^^ Omit the argument when you want to have auto-generated description.
       RUBY
     end
+
+    it 'ignores `specify` missing description in multi-line examples' do
+      expect_no_offenses(<<~RUBY)
+        specify do
+          expect(subject).to be_good
+        end
+      RUBY
+    end
+
+    it 'ignores `specify` missing description in single-line examples' do
+      expect_no_offenses(<<~RUBY)
+        specify { expect(subject).to be_good }
+      RUBY
+    end
+
+    it 'flags `specify` with an empty string for description' do
+      expect_offense(<<~RUBY)
+        specify('') { expect(subject).to be_good }
+                ^^ Omit the argument when you want to have auto-generated description.
+      RUBY
+    end
   end
 
   context 'with EnforcedStyle `disallow`' do
     let(:enforced_style) { 'disallow' }
 
-    it 'flags missing description in multi-line examples' do
-      expect_offense(<<-RUBY)
+    it 'flags `it` missing description in multi-line examples' do
+      expect_offense(<<~RUBY)
         it do
         ^^ Add a description.
           expect(subject).to be_good
@@ -74,19 +118,42 @@
       RUBY
     end
 
-    it 'flags missing description in single-line examples' do
-      expect_offense(<<-RUBY)
+    it 'flags `it` missing description in single-line examples' do
+      expect_offense(<<~RUBY)
         it { expect(subject).to be_good }
         ^^ Add a description.
       RUBY
     end
 
     it 'ignores `it` with a description' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it 'is good' do
           expect(subject).to be_good
         end
       RUBY
     end
+
+    it 'ignores `specify` missing description in multi-line examples' do
+      expect_no_offenses(<<~RUBY)
+        specify do
+          expect(subject).to be_good
+        end
+      RUBY
+    end
+
+    it 'flags `specify` missing description in single-line examples' do
+      expect_offense(<<~RUBY)
+        specify { expect(subject).to be_good }
+        ^^^^^^^ Add a description.
+      RUBY
+    end
+
+    it 'ignores `specify` with a description' do
+      expect_no_offenses(<<~RUBY)
+        specify 'is good' do
+          expect(subject).to be_good
+        end
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/example_wording_spec.rb b/spec/rubocop/cop/rspec/example_wording_spec.rb
index 9191bd922..5f93c79df 100644
--- a/spec/rubocop/cop/rspec/example_wording_spec.rb
+++ b/spec/rubocop/cop/rspec/example_wording_spec.rb
@@ -1,201 +1,408 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ExampleWording, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'with configuration' do
-    let(:cop_config) do
-      {
-        'CustomTransform' => { 'have' => 'has' },
-        'IgnoredWords'    => %w[only really]
-      }
-    end
+RSpec.describe RuboCop::Cop::RSpec::ExampleWording do
+  it 'ignores non-example blocks' do
+    expect_no_offenses('foo "should do something" do; end')
+  end
 
-    it 'ignores non-example blocks' do
-      expect_no_offenses('foo "should do something" do; end')
-    end
+  it 'finds description with `should` at the beginning' do
+    expect_offense(<<~RUBY)
+      it 'should do something' do
+          ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'finds description with `should` at the beginning' do
-      expect_offense(<<-RUBY)
-        it 'should do something' do
-            ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it 'does something' do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it 'does something' do
-        end
-      RUBY
-    end
+  it 'finds interpolated description with `should` at the beginning' do
+    expect_offense(<<~'RUBY')
+      it "should do #{:stuff}" do
+          ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'finds interpolated description with `should` at the beginning' do
-      expect_offense(<<-'RUBY')
-        it "should do #{:stuff}" do
-            ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~'RUBY')
+      it "does #{:stuff}" do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-'RUBY')
-        it "does #{:stuff}" do
-        end
-      RUBY
-    end
+  it 'finds description with `Should` at the beginning' do
+    expect_offense(<<~RUBY)
+      it 'Should do something' do
+          ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'finds description with `Should` at the beginning' do
-      expect_offense(<<-RUBY)
-        it 'Should do something' do
-            ^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it 'does something' do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it 'does something' do
-        end
-      RUBY
-    end
+  it "finds description with `shouldn't` at the beginning" do
+    expect_offense(<<~RUBY)
+      it "shouldn't do something" do
+          ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'finds description with `shouldn\'t` at the beginning' do
-      expect_offense(<<-RUBY)
-        it "shouldn't do something" do
-            ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it "does not do something" do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it "does not do something" do
-        end
-      RUBY
-    end
+  it "finds description with `SHOULDN'T` at the beginning" do
+    expect_offense(<<~RUBY)
+      it "SHOULDN'T do something" do
+          ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'finds description with `SHOULDN\'T` at the beginning' do
-      expect_offense(<<-RUBY)
-        it "SHOULDN'T do something" do
-            ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it "DOES NOT do something" do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it "DOES NOT do something" do
-        end
-      RUBY
-    end
+  it 'flags a lone should' do
+    expect_offense(<<~RUBY)
+      it 'should' do
+          ^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'flags a lone should' do
-      expect_offense(<<-RUBY)
-        it 'should' do
-            ^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it '' do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it '' do
-        end
-      RUBY
-    end
+  it 'flags a lone should not' do
+    expect_offense(<<~RUBY)
+      it 'should not' do
+          ^^^^^^^^^^ Do not use should when describing your tests.
+      end
+    RUBY
 
-    it 'flags a lone should not' do
-      expect_offense(<<-RUBY)
-        it 'should not' do
-            ^^^^^^^^^^ Do not use should when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it 'does not' do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it 'does not' do
-        end
-      RUBY
-    end
+  it 'finds description with `will` at the beginning' do
+    expect_offense(<<~RUBY)
+      it 'will do something' do
+          ^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
 
-    it 'finds leading its' do
-      expect_offense(<<-RUBY)
-        it "it does something" do
-            ^^^^^^^^^^^^^^^^^ Do not repeat 'it' when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~RUBY)
+      it 'does something' do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-RUBY)
-        it "does something" do
-        end
-      RUBY
-    end
+  it 'finds interpolated description with `will` at the beginning' do
+    expect_offense(<<~'RUBY')
+      it "will do #{:stuff}" do
+          ^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
 
-    it 'finds leading it in interpolated description' do
-      expect_offense(<<-'RUBY')
-        it "it does #{action}" do
-            ^^^^^^^^^^^^^^^^^ Do not repeat 'it' when describing your tests.
-        end
-      RUBY
+    expect_correction(<<~'RUBY')
+      it "does #{:stuff}" do
+      end
+    RUBY
+  end
 
-      expect_correction(<<-'RUBY')
-        it "does #{action}" do
-        end
-      RUBY
-    end
+  it 'finds description with `Will` at the beginning' do
+    expect_offense(<<~RUBY)
+      it 'Will do something' do
+          ^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
 
-    it "skips words beginning with 'it'" do
-      expect_no_offenses(<<-RUBY)
-        it 'itemizes items' do
-        end
-      RUBY
-    end
+    expect_correction(<<~RUBY)
+      it 'does something' do
+      end
+    RUBY
+  end
 
-    it 'skips descriptions without `should` at the beginning' do
-      expect_no_offenses(<<-RUBY)
-        it 'finds no should here' do
-        end
-      RUBY
-    end
+  it "finds description with `won't` at the beginning" do
+    expect_offense(<<~RUBY)
+      it "won't do something" do
+          ^^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
 
-    it 'skips descriptions starting with words that begin with `should`' do
-      expect_no_offenses(<<-RUBY)
-        it 'shoulders the burden' do
+    expect_correction(<<~RUBY)
+      it "does not do something" do
+      end
+    RUBY
+  end
+
+  it 'finds description with `won’t` at the beginning' do
+    expect_offense(<<~RUBY)
+      it "won’t do something" do
+          ^^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "does not do something" do
+      end
+    RUBY
+  end
+
+  it "finds description with `WON'T` at the beginning" do
+    expect_offense(<<~RUBY)
+      it "WON'T do something" do
+          ^^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "DOES NOT do something" do
+      end
+    RUBY
+  end
+
+  it 'finds description with `WON’T` at the beginning' do
+    expect_offense(<<~RUBY)
+      it "WON’T do something" do
+          ^^^^^^^^^^^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "DOES NOT do something" do
+      end
+    RUBY
+  end
+
+  it 'flags a lone will' do
+    expect_offense(<<~RUBY)
+      it 'will' do
+          ^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it '' do
+      end
+    RUBY
+  end
+
+  it 'flags a lone will not' do
+    expect_offense(<<~RUBY)
+      it 'will not' do
+          ^^^^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'does not' do
+      end
+    RUBY
+  end
+
+  it "flags a lone won't" do
+    expect_offense(<<~RUBY)
+      it "won't" do
+          ^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "does not" do
+      end
+    RUBY
+  end
+
+  it 'flags a lone won’t' do
+    expect_offense(<<~RUBY)
+      it "won’t" do
+          ^^^^^ Do not use the future tense when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "does not" do
+      end
+    RUBY
+  end
+
+  it 'finds leading its' do
+    expect_offense(<<~RUBY)
+      it "it does something" do
+          ^^^^^^^^^^^^^^^^^ Do not repeat 'it' when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it "does something" do
+      end
+    RUBY
+  end
+
+  it 'finds leading it in interpolated description' do
+    expect_offense(<<~'RUBY')
+      it "it does #{action}" do
+          ^^^^^^^^^^^^^^^^^ Do not repeat 'it' when describing your tests.
+      end
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      it "does #{action}" do
+      end
+    RUBY
+  end
+
+  it "skips words beginning with 'it'" do
+    expect_no_offenses(<<~RUBY)
+      it 'itemizes items' do
+      end
+    RUBY
+  end
+
+  it 'skips descriptions without `should` at the beginning' do
+    expect_no_offenses(<<~RUBY)
+      it 'finds no should here' do
+      end
+    RUBY
+  end
+
+  it 'skips descriptions starting with words that begin with `should`' do
+    expect_no_offenses(<<~RUBY)
+      it 'shoulders the burden' do
+      end
+    RUBY
+  end
+
+  it 'skips interpolated description without literal `should` at the start' do
+    expect_no_offenses(<<~'RUBY')
+      it "#{should} not be here" do
+      end
+    RUBY
+  end
+
+  it 'flags \-separated multiline strings' do
+    expect_offense(<<~'RUBY')
+      it 'should do something ' \
+          ^^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+          'and correctly fix' do
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'does something and correctly fix' do
+      end
+    RUBY
+  end
+
+  it 'flags \-separated multiline interpolated strings' do
+    expect_offense(<<~'RUBY')
+      it "should do something " \
+          ^^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
+          "with #{object}" do
+      end
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      it "does something with #{object}" do
+      end
+    RUBY
+  end
+
+  it 'ignores heredocs' do
+    expect_offense(<<~RUBY)
+      it <<~DESC do
+          ^^^^^ Do not use should when describing your tests.
+        should not start with this word
+      DESC
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'flags an unclear description' do
+    expect_offense(<<~RUBY)
+      it "works" do
+          ^^^^^ Your example description is insufficient.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'flags an unclear description despite extra spaces' do
+    expect_offense(<<~RUBY)
+      it "  works    " do
+          ^^^^^^^^^^^ Your example description is insufficient.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'flags an unclear description despite uppercase and lowercase strings' do
+    expect_offense(<<~RUBY)
+      it "WOrKs " do
+          ^^^^^^ Your example description is insufficient.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  context 'when `DisallowedExamples: Workz`' do
+    let(:cop_config) { { 'DisallowedExamples' => ['Workz'] } }
+
+    it 'finds a valid sentence across two lines' do
+      expect_no_offenses(<<~'RUBY')
+        it "workz " \
+          "totally fine " do
         end
       RUBY
     end
 
-    it 'skips interpolated description without literal `should` at the start' do
-      expect_no_offenses(<<-'RUBY')
-        it "#{should} not be here" do
+    it 'finds an invalid example across two lines' do
+      expect_offense(<<~'RUBY')
+        it "workz" \
+            ^^^^^^^^ Your example description is insufficient.
+          " " do
         end
       RUBY
+
+      expect_no_corrections
     end
 
-    it 'flags \-separated multiline strings' do
-      expect_offense(<<-RUBY)
-        it 'should do something '\\
-            ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-            'and correctly fix' do
+    it 'flags an unclear description' do
+      expect_offense(<<~RUBY)
+        it "workz" do
+            ^^^^^ Your example description is insufficient.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
-        it 'does something and correctly fix' do
-        end
-      RUBY
+      expect_no_corrections
     end
 
-    it 'flags \-separated multiline interpolated strings' do
-      expect_offense(<<-'RUBY')
-        it "should do something "\
-            ^^^^^^^^^^^^^^^^^^^^^^ Do not use should when describing your tests.
-            "with #{object}" do
+    it 'flags an unclear description despite uppercase and lowercase strings' do
+      expect_offense(<<~RUBY)
+        it "WOrKz " do
+            ^^^^^^ Your example description is insufficient.
         end
       RUBY
 
-      expect_correction(<<-'RUBY')
-        it "does something with #{object}" do
-        end
-      RUBY
+      expect_no_corrections
     end
   end
-
-  context 'when configuration is empty' do
-    include_examples 'autocorrect',
-                     'it "should have trait" do end',
-                     'it "haves trait" do end'
-
-    include_examples 'autocorrect',
-                     'it "should only fail" do end',
-                     'it "onlies fail" do end'
-  end
 end
diff --git a/spec/rubocop/cop/rspec/excessive_docstring_spacing_spec.rb b/spec/rubocop/cop/rspec/excessive_docstring_spacing_spec.rb
new file mode 100644
index 000000000..00c071bb6
--- /dev/null
+++ b/spec/rubocop/cop/rspec/excessive_docstring_spacing_spec.rb
@@ -0,0 +1,775 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ExcessiveDocstringSpacing do
+  it 'ignores non-example blocks' do
+    expect_no_offenses('foo "should do something" do; end')
+  end
+
+  context 'when using `describe`' do
+    it 'skips blocks without text' do
+      expect_no_offenses(<<~RUBY)
+        describe do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading whitespace' do
+      expect_offense(<<~RUBY)
+        describe '  #mymethod' do
+                  ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading em space' do
+      expect_offense(<<~RUBY)
+        describe '\u3000\u3000#mymethod' do
+                  ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading non-breaking space' do
+      expect_offense(<<~RUBY)
+        describe '\u00a0#mymethod' do
+                  ^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with leading whitespace' do
+      expect_offense(<<~'RUBY')
+        describe "  ##{:stuff}" do
+                  ^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        describe "##{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing whitespace' do
+      expect_offense(<<~RUBY)
+        describe '#mymethod  ' do
+                  ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing em space' do
+      expect_offense(<<~RUBY)
+        describe '#mymethod\u3000\u3000' do
+                  ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        describe '#mymethod\u00a0' do
+                  ^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading and trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        describe '\u00a0#mymethod\u00a0' do
+                  ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with trailing whitespace' do
+      expect_offense(<<~'RUBY')
+        describe "##{:stuff}  " do
+                  ^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        describe "##{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'flags lone whitespace' do
+      expect_offense(<<~RUBY)
+        describe '   ' do
+                  ^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '' do
+        end
+      RUBY
+    end
+
+    it 'skips descriptions without any excessive whitespace' do
+      expect_no_offenses(<<~RUBY)
+        describe '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'skips interpolated description without leading whitespace' do
+      expect_no_offenses(<<~'RUBY')
+        describe "##{should}" do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        describe '#mymethod   (is cool)' do
+                  ^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod (is cool)' do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with multiple inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        describe '#mymethod      (  is     cool  )' do
+                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod ( is cool )' do
+        end
+      RUBY
+    end
+
+    it 'skips \-separated multiline strings whose trailing whitespace ' \
+       'makes sense' do
+      expect_no_offenses(<<~'RUBY')
+        describe '#mymethod ' \
+            '(is cool)' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline strings whose trailing whitespace ' \
+       'does not make sense' do
+      expect_offense(<<~'RUBY')
+        describe '#mymethod   ' \
+                  ^^^^^^^^^^^^^^^ Excessive whitespace.
+            '(is cool)' do
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        describe '#mymethod (is cool)' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline interpolated strings with ' \
+       'leading whitespace' do
+      expect_offense(<<~'RUBY')
+        describe "  ##{object} " \
+                  ^^^^^^^^^^^^^^^^ Excessive whitespace.
+            "(is cool)" do
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        describe "##{object} (is cool)" do
+        end
+      RUBY
+    end
+  end
+
+  context 'when using `context`' do
+    it 'skips blocks without text' do
+      expect_no_offenses(<<~RUBY)
+        context do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading whitespace' do
+      expect_offense(<<~RUBY)
+        context '  when doing something' do
+                 ^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context 'when doing something' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading non-breaking space' do
+      expect_offense(<<~RUBY)
+        context '\u00a0#mymethod' do
+                 ^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with leading whitespace' do
+      expect_offense(<<~'RUBY')
+        context "  when doing something #{:stuff}" do
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        context "when doing something #{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing whitespace' do
+      expect_offense(<<~RUBY)
+        context 'when doing something  ' do
+                 ^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context 'when doing something' do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        context '#mymethod\u00a0' do
+                 ^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading and trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        context '\u00a0#mymethod\u00a0' do
+                 ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context '#mymethod' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with trailing whitespace' do
+      expect_offense(<<~'RUBY')
+        context "when doing #{:stuff}  " do
+                 ^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        context "when doing #{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with both trailing and leading ' \
+       'whitespace' do
+      expect_offense(<<~'RUBY')
+        context "  when doing #{:stuff}  " do
+                 ^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        context "when doing #{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'flags lone whitespace' do
+      expect_offense(<<~RUBY)
+        context '   ' do
+                 ^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context '' do
+        end
+      RUBY
+    end
+
+    it 'skips descriptions without any excessive whitespace' do
+      expect_no_offenses(<<~RUBY)
+        context 'when doing something' do
+        end
+      RUBY
+    end
+
+    it 'skips interpolated description without leading whitespace' do
+      expect_no_offenses(<<~'RUBY')
+        context "#{should} the value be incorrect" do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        context 'when   something' do
+                 ^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context 'when something' do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with multiple inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        context 'when     something    cool happens!' do
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context 'when something cool happens!' do
+        end
+      RUBY
+    end
+
+    it 'skips \-separated multiline strings whose trailing whitespace ' \
+       'makes sense' do
+      expect_no_offenses(<<~'RUBY')
+        context 'when doing something ' \
+            'like this' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline strings whose trailing whitespace ' \
+       'does not make sense' do
+      expect_offense(<<~'RUBY')
+        context 'when doing something   ' \
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            'like this' do
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        context 'when doing something like this' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline interpolated strings with leading ' \
+       'whitespace' do
+      expect_offense(<<~'RUBY')
+        context "  when doing something " \
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            "like #{object}" do
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        context "when doing something like #{object}" do
+        end
+      RUBY
+    end
+  end
+
+  context 'when using `it`' do
+    it 'skips blocks without text' do
+      expect_no_offenses(<<~RUBY)
+        it do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading whitespace' do
+      expect_offense(<<~RUBY)
+        it '  does something' do
+            ^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading non-breaking space' do
+      expect_offense(<<~RUBY)
+        it '\u00a0does something' do
+            ^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with leading whitespace' do
+      expect_offense(<<~'RUBY')
+        it "  does something #{:stuff}" do
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        it "does something #{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing whitespace' do
+      expect_offense(<<~RUBY)
+        it 'does something  ' do
+            ^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds description with trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        it 'does something\u00a0' do
+            ^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds description with leading and trailing non-breaking space' do
+      expect_offense(<<~RUBY)
+        it '\u00a0does something\u00a0' do
+            ^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds interpolated description with trailing whitespace' do
+      expect_offense(<<~'RUBY')
+        it "does something #{:stuff}  " do
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        it "does something #{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'handles one-word descriptions' do
+      expect_offense(<<~RUBY)
+        it "tests  " do
+            ^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it "tests" do
+        end
+      RUBY
+    end
+
+    it 'handles interpolated one-word descriptions' do
+      expect_offense(<<~'RUBY')
+        it "#{:stuff}  " do
+            ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        it "#{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'handles descriptions starting with an interpolated value' do
+      expect_offense(<<~'RUBY')
+        it "#{:stuff} something   " do
+            ^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        it "#{:stuff} something" do
+        end
+      RUBY
+    end
+
+    it 'flags lone whitespace' do
+      expect_offense(<<~RUBY)
+        it '   ' do
+            ^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it '' do
+        end
+      RUBY
+    end
+
+    it 'skips descriptions without any excessive whitespace' do
+      expect_no_offenses(<<~RUBY)
+        it 'finds no should here' do
+        end
+      RUBY
+    end
+
+    it 'skips interpolated description without leading whitespace' do
+      expect_no_offenses(<<~'RUBY')
+        it "#{should} not be here" do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        it 'does   something' do
+            ^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something' do
+        end
+      RUBY
+    end
+
+    it 'finds descriptions with multiple inner extra whitespace' do
+      expect_offense(<<~RUBY)
+        it 'does  something      cool!' do
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something cool!' do
+        end
+      RUBY
+    end
+
+    it 'skips \-separated multiline strings whose trailing whitespace ' \
+       'makes sense' do
+      expect_no_offenses(<<~'RUBY')
+        it 'should do something ' \
+            'and correctly fix' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline strings whose trailing whitespace ' \
+       'does not make sense' do
+      expect_offense(<<~'RUBY')
+        it 'does something   ' \
+            ^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            'and correctly fix' do
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it 'does something and correctly fix' do
+        end
+      RUBY
+    end
+
+    it 'flags \-separated multiline interpolated strings with leading ' \
+       'whitespace' do
+      expect_offense(<<~'RUBY')
+        it "  does something " \
+            ^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            "with #{object}" do
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        it "does something with #{object}" do
+        end
+      RUBY
+    end
+  end
+
+  context 'when using other common example groups' do
+    it 'supports `xcontext`' do
+      expect_offense(<<~RUBY)
+        xcontext "when testing  " do
+                  ^^^^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        xcontext "when testing" do
+        end
+      RUBY
+    end
+
+    it 'supports `feature`' do
+      expect_offense(<<~'RUBY')
+        feature "  #{:stuff}" do
+                 ^^^^^^^^^^^ Excessive whitespace.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        feature "#{:stuff}" do
+        end
+      RUBY
+    end
+
+    it 'supports `its`' do
+      expect_offense(<<~RUBY)
+        its("  length  ") { should eq(1) }
+             ^^^^^^^^^^ Excessive whitespace.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        its("length") { should eq(1) }
+      RUBY
+    end
+
+    it 'supports `skip` (with a block)' do
+      expect_offense(<<~'RUBY')
+        skip '  this   please   ' \
+              ^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            '  and thank you  !' do
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        skip 'this please and thank you !' do
+        end
+      RUBY
+    end
+
+    it 'supports `skip` (without a block)' do
+      expect_offense(<<~'RUBY')
+        skip '  this   please   ' \
+              ^^^^^^^^^^^^^^^^^^^^^ Excessive whitespace.
+            '  and thank you  !'
+      RUBY
+
+      expect_correction(<<~RUBY)
+        skip 'this please and thank you !'
+      RUBY
+    end
+  end
+
+  it 'does not consider indented whitespace excessive' do
+    expect_no_offenses(<<~RUBY)
+      context "some context" do
+        [].each do |i|
+          it "does something, lala1: #\{i[:a].first} - #\{i[:a].last},
+              lala2: #\{i[:a].first} - #\{i[:a].last}" do
+            # something
+
+            # expect
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores heredocs' do
+    expect_no_offenses(<<~RUBY)
+      it <<~DESC do
+        does not remove
+          another comments reports,
+          another comments votes,
+          another   comments image,
+          another comments feeds,
+          another comments   notifications,
+        another comments public feeds,
+          another comments subs
+      DESC
+      end
+    RUBY
+  end
+
+  it 'flags \-separated multiline interpolated strings with ' \
+     'leading whitespace and corrects trailing empty lines' do
+    expect_offense(<<~'RUBY')
+      describe "  ##{object} " \
+                ^^^^^^^^^^^^^^^^ Excessive whitespace.
+          "(is cool)" \
+            ' ' \
+            " " do
+      end
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      describe "##{object} (is cool)" do
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/expect_actual_spec.rb b/spec/rubocop/cop/rspec/expect_actual_spec.rb
index 852c1c5c8..14cf18ac7 100644
--- a/spec/rubocop/cop/rspec/expect_actual_spec.rb
+++ b/spec/rubocop/cop/rspec/expect_actual_spec.rb
@@ -1,25 +1,23 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ExpectActual, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ExpectActual do
   it 'flags numeric literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(123).to eq(bar)
-                 ^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^ Provide the actual value you are testing to `expect(...)`.
           expect(12.3).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^ Provide the actual value you are testing to `expect(...)`.
           expect(1i).to eq(bar)
-                 ^^ Provide the actual you are testing to `expect(...)`.
+                 ^^ Provide the actual value you are testing to `expect(...)`.
           expect(1r).to eq(bar)
-                 ^^ Provide the actual you are testing to `expect(...)`.
+                 ^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(123)
@@ -32,18 +30,18 @@
   end
 
   it 'flags boolean literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(true).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^ Provide the actual value you are testing to `expect(...)`.
           expect(false).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(true)
@@ -54,18 +52,18 @@
   end
 
   it 'flags string and symbol literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect("foo").to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^ Provide the actual value you are testing to `expect(...)`.
           expect(:foo).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq("foo")
@@ -76,16 +74,16 @@
   end
 
   it 'flags literal nil value within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(nil).to eq(bar)
-                 ^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(nil)
@@ -95,7 +93,7 @@
   end
 
   it 'does not flag dynamic values within expect(...)' do
-    expect_no_offenses(<<-'RUBY')
+    expect_no_offenses(<<~'RUBY')
       describe Foo do
         it 'uses expect correctly' do
           expect(foo).to eq(bar)
@@ -107,18 +105,18 @@
   end
 
   it 'flags arrays containing only literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect([123]).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^ Provide the actual value you are testing to `expect(...)`.
           expect([[123]]).to eq(bar)
-                 ^^^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq([123])
@@ -129,18 +127,18 @@
   end
 
   it 'flags hashes containing only literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(foo: 1, bar: 2).to eq(bar)
-                 ^^^^^^^^^^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^^^^^^^^^^ Provide the actual value you are testing to `expect(...)`.
           expect(foo: 1, bar: [{}]).to eq(bar)
-                 ^^^^^^^^^^^^^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^^^^^^^^^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(foo: 1, bar: 2)
@@ -150,19 +148,41 @@
     RUBY
   end
 
+  it 'autocorrects literal hash when expected is without parentheses' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        it 'uses expect incorrectly' do
+          expect(foo: 1, bar: 2).to eq bar
+                 ^^^^^^^^^^^^^^ Provide the actual value you are testing to `expect(...)`.
+          expect({ foo: 1, bar: 2 }).to eq bar
+                 ^^^^^^^^^^^^^^^^^^ Provide the actual value you are testing to `expect(...)`.
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        it 'uses expect incorrectly' do
+          expect(bar).to eq(foo: 1, bar: 2)
+          expect(bar).to eq({ foo: 1, bar: 2 })
+        end
+      end
+    RUBY
+  end
+
   it 'flags ranges containing only literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(1..2).to eq(bar)
-                 ^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^ Provide the actual value you are testing to `expect(...)`.
           expect(1...2).to eq(bar)
-                 ^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(1..2)
@@ -173,16 +193,16 @@
   end
 
   it 'flags regexps containing only literal values within expect(...)' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(/foo|bar/).to eq(bar)
-                 ^^^^^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eq(/foo|bar/)
@@ -192,7 +212,7 @@
   end
 
   it 'does not flag complex values with dynamic parts within expect(...)' do
-    expect_no_offenses(<<-'RUBY')
+    expect_no_offenses(<<~'RUBY')
       describe Foo do
         it 'uses expect incorrectly' do
           expect.to eq(bar)
@@ -222,7 +242,7 @@
       describe Foo do
         it 'uses expect incorrectly' do
           expect(true).to be(a)
-                 ^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
@@ -241,7 +261,7 @@
       describe Foo do
         it 'uses expect incorrectly' do
           expect(1).to be == a
-                 ^ Provide the actual you are testing to `expect(...)`.
+                 ^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
@@ -256,16 +276,16 @@
   end
 
   it 'flags with `eql` matcher' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(1).to eql(bar)
-                 ^ Provide the actual you are testing to `expect(...)`.
+                 ^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to eql(1)
@@ -275,16 +295,16 @@
   end
 
   it 'flags with `equal` matcher' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(1).to equal(bar)
-                 ^ Provide the actual you are testing to `expect(...)`.
+                 ^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect(bar).to equal(1)
@@ -293,12 +313,25 @@
     RUBY
   end
 
-  it 'flags but does not autocorrect violations for other matchers' do
-    expect_offense(<<-RUBY)
+  it 'flags but does not autocorrect offenses for other matchers' do
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses expect incorrectly' do
           expect([1,2,3]).to include(a)
-                 ^^^^^^^ Provide the actual you are testing to `expect(...)`.
+                 ^^^^^^^ Provide the actual value you are testing to `expect(...)`.
+        end
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'flags but does not autocorrect when the actual value is also a literal' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        it 'uses expect incorrectly' do
+          expect([1,2,3]).to eq([1, 2, 3])
+                 ^^^^^^^ Provide the actual value you are testing to `expect(...)`.
         end
       end
     RUBY
@@ -306,16 +339,25 @@
     expect_no_corrections
   end
 
+  it 'does not flag when the matcher is a rails routing matcher' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        it 'routes correctly' do
+          expect({:get => "foo"}).to be_routable
+          expect({:get => "foo"}).to route_to("bar#baz")
+        end
+      end
+    RUBY
+  end
+
   context 'when inspecting rspec-rails routing specs' do
     let(:cop_config) { {} }
 
     it 'ignores rspec-rails routing specs' do
-      inspect_source(
-        'expect(get: "/foo").to be_routeable',
+      expect_no_offenses(
+        'expect(get: "/foo").to be_routable',
         'spec/routing/foo_spec.rb'
       )
-
-      expect(cop.offenses).to be_empty
     end
   end
 end
diff --git a/spec/rubocop/cop/rspec/expect_change_spec.rb b/spec/rubocop/cop/rspec/expect_change_spec.rb
index e284983fa..e26b54234 100644
--- a/spec/rubocop/cop/rspec/expect_change_spec.rb
+++ b/spec/rubocop/cop/rspec/expect_change_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ExpectChange, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ExpectChange do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
@@ -11,30 +9,30 @@
     let(:enforced_style) { 'method_call' }
 
     it 'flags blocks that contain simple message sending' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           expect { run }.to change { User.count }.by(1)
                             ^^^^^^^^^^^^^^^^^^^^^ Prefer `change(User, :count)`.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           expect { run }.to change(User, :count).by(1)
         end
       RUBY
     end
 
-    it 'ignores blocks that cannot be converted to obj/attribute pair' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores blocks when the method is called with arguments' do
+      expect_no_offenses(<<~RUBY)
         it do
           expect { run }.to change { User.sum(:points) }
         end
       RUBY
     end
 
-    it 'ignores change method of object that happens to receive a block' do
-      expect_no_offenses(<<-RUBY)
+    it 'ignores when not an expectation' do
+      expect_no_offenses(<<~RUBY)
         it do
           Record.change { User.count }
         end
@@ -42,12 +40,87 @@
     end
 
     it 'flags implicit block expectation syntax' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           expect(run).to change { User.count }.by(1)
                          ^^^^^^^^^^^^^^^^^^^^^ Prefer `change(User, :count)`.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect(run).to change(User, :count).by(1)
+        end
+      RUBY
+    end
+
+    it 'ignores the usage that adheres to the enforced style' do
+      expect_no_offenses(<<~RUBY)
+        it do
+          expect { run }.to change(User, :count).by(1)
+        end
+      RUBY
+    end
+
+    it 'flags when the received is a namespaced constant' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change { User::Token::Auth.count }.by(1)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `change(User::Token::Auth, :count)`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change(User::Token::Auth, :count).by(1)
+        end
+      RUBY
+    end
+
+    it 'flags when the receiver is a top-level constant' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change { ::User.count }.by(1)
+                            ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `change(::User, :count)`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change(::User, :count).by(1)
+        end
+      RUBY
+    end
+
+    it 'flags a method call on an object' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change { user.name }.to('Jack')
+                            ^^^^^^^^^^^^^^^^^^^^ Prefer `change(user, :name)`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change(user, :name).to('Jack')
+        end
+      RUBY
+    end
+
+    it 'ignores multiple chained method calls' do
+      expect_no_offenses(<<~RUBY)
+        it do
+          expect { run }.to change { user.reload.name }
+        end
+      RUBY
+    end
+
+    it 'ignores a variable/method' do
+      expect_no_offenses(<<~RUBY)
+        it do
+          expect { run }.to change { results }.to([])
+        end
+      RUBY
     end
   end
 
@@ -55,37 +128,127 @@
     let(:enforced_style) { 'block' }
 
     it 'flags change matcher without block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           expect { run }.to change(User, :count).by(1)
                             ^^^^^^^^^^^^^^^^^^^^ Prefer `change { User.count }`.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           expect { run }.to change { User.count }.by(1)
         end
       RUBY
     end
 
+    it 'flags change matcher when receiver is a namespaced constant' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change(User::Token::Auth, :count).by(1)
+                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `change { User::Token::Auth.count }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change { User::Token::Auth.count }.by(1)
+        end
+      RUBY
+    end
+
     it 'flags change matcher when receiver is a variable' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
-          expect { run }.to change(User, :count)
-                            ^^^^^^^^^^^^^^^^^^^^ Prefer `change { User.count }`.
+          expect { run }.to change(user, :count)
+                            ^^^^^^^^^^^^^^^^^^^^ Prefer `change { user.count }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change { user.count }
+        end
+      RUBY
+    end
+
+    it 'flags change matcher when message is a string' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change(user, 'status')
+                            ^^^^^^^^^^^^^^^^^^^^^^ Prefer `change { user.status }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change { user.status }
+        end
+      RUBY
+    end
+
+    it 'registers an offense for change matcher with chained method call' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { paint_users! }.to change(users.green, :count).by(1)
+                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `change { users.green.count }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { paint_users! }.to change { users.green.count }.by(1)
+        end
+      RUBY
+    end
+
+    it 'flags change matcher when receiver is a top-level constant' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { run }.to change(::User, :count)
+                            ^^^^^^^^^^^^^^^^^^^^^^ Prefer `change { ::User.count }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { run }.to change { ::User.count }
         end
       RUBY
+    end
 
-      expect_correction(<<-RUBY)
+    it 'registers an offense for change matcher with an instance variable' do
+      expect_offense(<<~RUBY)
         it do
-          expect { run }.to change { User.count }
+          expect { paint_users! }.to change(@food, :taste).to(:sour)
+                                     ^^^^^^^^^^^^^^^^^^^^^ Prefer `change { @food.taste }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { paint_users! }.to change { @food.taste }.to(:sour)
+        end
+      RUBY
+    end
+
+    it 'registers an offense for change matcher with a global variable' do
+      expect_offense(<<~RUBY)
+        it do
+          expect { paint_users! }.to change($token, :value).to(nil)
+                                     ^^^^^^^^^^^^^^^^^^^^^^ Prefer `change { $token.value }`.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect { paint_users! }.to change { $token.value }.to(nil)
         end
       RUBY
     end
 
     it 'ignores methods called change' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           record.change(user, :count)
         end
@@ -93,12 +256,18 @@
     end
 
     it 'flags implicit block expectation syntax' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           expect(run).to change(User, :count).by(1)
                          ^^^^^^^^^^^^^^^^^^^^ Prefer `change { User.count }`.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          expect(run).to change { User.count }.by(1)
+        end
+      RUBY
     end
   end
 end
diff --git a/spec/rubocop/cop/rspec/expect_in_hook_spec.rb b/spec/rubocop/cop/rspec/expect_in_hook_spec.rb
index 47593c54a..49f56435a 100644
--- a/spec/rubocop/cop/rspec/expect_in_hook_spec.rb
+++ b/spec/rubocop/cop/rspec/expect_in_hook_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ExpectInHook do
-  subject(:cop) { described_class.new }
-
   it 'adds an offense for `expect` in `before` hook' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         expect(something).to eq('foo')
         ^^^^^^ Do not use `expect` in `before` hook
@@ -17,7 +15,7 @@
   end
 
   it 'adds an offense for `expect` in `after` hook' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       after do
         expect(something).to eq('foo')
         ^^^^^^ Do not use `expect` in `after` hook
@@ -30,7 +28,7 @@
   end
 
   it 'adds an offense for `expect` in `around` hook' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       around do
         expect(something).to eq('foo')
         ^^^^^^ Do not use `expect` in `around` hook
@@ -43,7 +41,7 @@
   end
 
   it 'adds an offense for `expect` with block in `before` hook' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         expect { something }.to eq('foo')
         ^^^^^^ Do not use `expect` in `before` hook
@@ -52,14 +50,14 @@
   end
 
   it 'accepts an empty `before` hook' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       before do
       end
     RUBY
   end
 
   it 'accepts `allow` in `before` hook' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       before do
         allow(something).to receive(:foo)
         allow_any_instance_of(something).to receive(:foo)
@@ -68,7 +66,7 @@
   end
 
   it 'accepts `expect` in `it`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it do
         expect(something).to eq('foo')
         is_expected.to eq('foo')
@@ -76,4 +74,20 @@
       end
     RUBY
   end
+
+  context 'when Ruby 2.7', :ruby27 do
+    it 'adds an offense for `expect` in `around` hook' do
+      expect_offense(<<~RUBY)
+        around do
+          expect(something).to eq('foo')
+          ^^^^^^ Do not use `expect` in `around` hook
+          is_expected(something).to eq('foo')
+          ^^^^^^^^^^^ Do not use `is_expected` in `around` hook
+          expect_any_instance_of(Something).to receive(:foo)
+          ^^^^^^^^^^^^^^^^^^^^^^ Do not use `expect_any_instance_of` in `around` hook
+          _1.run
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/expect_in_let_spec.rb b/spec/rubocop/cop/rspec/expect_in_let_spec.rb
new file mode 100644
index 000000000..6bc6d53d8
--- /dev/null
+++ b/spec/rubocop/cop/rspec/expect_in_let_spec.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ExpectInLet do
+  it 'adds an offense for `expect` in let' do
+    expect_offense(<<~RUBY)
+      let(:foo) do
+        expect(something).to eq 'foo'
+        ^^^^^^ Do not use `expect` in let
+      end
+    RUBY
+  end
+
+  it 'adds an offense for `is_expected` in let' do
+    expect_offense(<<~RUBY)
+      let(:foo) do
+        is_expected.to eq 'foo'
+        ^^^^^^^^^^^ Do not use `is_expected` in let
+      end
+    RUBY
+  end
+
+  it 'adds an offense for `expect_any_instance_of` in let' do
+    expect_offense(<<~RUBY)
+      let(:foo) do
+        expect_any_instance_of(Something).to receive :foo
+        ^^^^^^^^^^^^^^^^^^^^^^ Do not use `expect_any_instance_of` in let
+      end
+    RUBY
+  end
+
+  it 'adds offenses for multiple expectations in let' do
+    expect_offense(<<~RUBY)
+      let(:foo) do
+        expect(something).to eq 'foo'
+        ^^^^^^ Do not use `expect` in let
+        is_expected.to eq 'foo'
+        ^^^^^^^^^^^ Do not use `is_expected` in let
+      end
+    RUBY
+  end
+
+  it 'accepts an empty let' do
+    expect_no_offenses(<<~RUBY)
+      let(:foo) {}
+    RUBY
+  end
+
+  it 'accepts `expect` in `it`' do
+    expect_no_offenses(<<~RUBY)
+      it do
+        expect(something).to eq 'foo'
+        is_expected.to eq 'foo'
+        expect_any_instance_of(Something).to receive :foo
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/expect_output_spec.rb b/spec/rubocop/cop/rspec/expect_output_spec.rb
index 20308e028..7aab14543 100644
--- a/spec/rubocop/cop/rspec/expect_output_spec.rb
+++ b/spec/rubocop/cop/rspec/expect_output_spec.rb
@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 RSpec.describe RuboCop::Cop::RSpec::ExpectOutput do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for overwriting $stdout within an example' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       specify do
         $stdout = StringIO.new
         ^^^^^^^ Use `expect { ... }.to output(...).to_stdout` instead of mutating $stdout.
@@ -16,7 +12,7 @@
 
   it 'registers an offense for overwriting $stderr ' \
      'within an example scoped hook' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before(:each) do
         $stderr = StringIO.new
         ^^^^^^^ Use `expect { ... }.to output(...).to_stderr` instead of mutating $stderr.
@@ -25,7 +21,7 @@
   end
 
   it 'does not register an offense for interacting with $stdout' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       specify do
         $stdout.puts("hi")
       end
@@ -33,7 +29,7 @@
   end
 
   it 'does not flag assignments to other global variables' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       specify do
         $blah = StringIO.new
       end
@@ -41,7 +37,7 @@
   end
 
   it 'does not flag assignments to $stdout outside of example scope' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       before(:suite) do
         $stderr = StringIO.new
       end
@@ -49,7 +45,7 @@
   end
 
   it 'does not flag assignments to $stdout in example_group scope' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         $stderr = StringIO.new
       end
diff --git a/spec/rubocop/cop/rspec/factory_bot/attribute_defined_statically_spec.rb b/spec/rubocop/cop/rspec/factory_bot/attribute_defined_statically_spec.rb
deleted file mode 100644
index 2e44e5a04..000000000
--- a/spec/rubocop/cop/rspec/factory_bot/attribute_defined_statically_spec.rb
+++ /dev/null
@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::FactoryBot::AttributeDefinedStatically do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for offending code' do
-    expect_offense(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          title "Something"
-          ^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          published_at 1.day.from_now
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          status [:draft, :published].sample
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          created_at 1.day.ago
-          ^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          update_times [Time.current]
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          meta_tags(foo: Time.current)
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-        end
-      end
-    RUBY
-  end
-
-  it 'registers an offense in a trait' do
-    expect_offense(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          trait :published do
-            title "Something"
-            ^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-            published_at 1.day.from_now
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'registers an offense in a transient block' do
-    expect_offense(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          transient do
-            title "Something"
-            ^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-            published_at 1.day.from_now
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'registers an offense for an attribute defined on `self`' do
-    expect_offense(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          self.start { Date.today }
-          self.end Date.tomorrow
-          ^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-        end
-      end
-    RUBY
-  end
-
-  it 'registers an offense for attributes defined on explicit receiver' do
-    expect_offense(<<-RUBY)
-      FactoryBot.define do
-        factory :post do |post_definition|
-          post_definition.end Date.tomorrow
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          post_definition.trait :published do |published_definition|
-            published_definition.published_at 1.day.from_now
-            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use a block to declare attribute values.
-          end
-        end
-      end
-    RUBY
-  end
-
-  it 'accepts valid factory definitions' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          trait :published do
-            published_at { 1.day.from_now }
-          end
-          created_at { 1.day.ago }
-          status { :draft }
-          comments_count { 0 }
-          title { "Static" }
-          description { FFaker::Lorem.paragraph(10) }
-          recent_statuses { [] }
-          tags { { like_count: 2 } }
-
-          before(:create, &:initialize_something)
-          after(:create, &:rebuild_cache)
-        end
-      end
-    RUBY
-  end
-
-  it 'does not add offense if out of factory bot block' do
-    expect_no_offenses(<<-RUBY)
-      status [:draft, :published].sample
-      published_at 1.day.from_now
-      created_at 1.day.ago
-      update_times [Time.current]
-      meta_tags(foo: Time.current)
-    RUBY
-  end
-
-  it 'does not add offense if method called on another object' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :post do |post_definition|
-          Registrar.register :post_factory
-        end
-      end
-    RUBY
-  end
-
-  it 'does not add offense if method called on a local variable' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :post do |post_definition|
-          local = Registrar
-          local.register :post_factory
-        end
-      end
-    RUBY
-  end
-
-  it 'accepts valid association definitions' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          author age: 42, factory: :user
-        end
-      end
-    RUBY
-  end
-
-  it 'accepts valid sequence definition' do
-    expect_no_offenses(<<-RUBY)
-      FactoryBot.define do
-        factory :post do
-          sequence :negative_numbers, &:-@
-        end
-      end
-    RUBY
-  end
-
-  bad = <<-RUBY
-    FactoryBot.define do
-      factory :post do
-        title "Something"
-        comments_count 0
-        tag Tag::MAGIC
-        recent_statuses []
-        status([:draft, :published].sample)
-        published_at 1.day.from_now
-        created_at(1.day.ago)
-        updated_at Time.current
-        update_times [Time.current]
-        meta_tags(foo: Time.current)
-        other_tags({ foo: Time.current })
-        options color: :blue
-        other_options Tag::MAGIC => :magic
-        self.end Date.tomorrow
-
-        trait :old do
-          published_at 1.week.ago
-        end
-      end
-    end
-  RUBY
-
-  corrected = <<-RUBY
-    FactoryBot.define do
-      factory :post do
-        title { "Something" }
-        comments_count { 0 }
-        tag { Tag::MAGIC }
-        recent_statuses { [] }
-        status { [:draft, :published].sample }
-        published_at { 1.day.from_now }
-        created_at { 1.day.ago }
-        updated_at { Time.current }
-        update_times { [Time.current] }
-        meta_tags { { foo: Time.current } }
-        other_tags { { foo: Time.current } }
-        options { { color: :blue } }
-        other_options { { Tag::MAGIC => :magic } }
-        self.end { Date.tomorrow }
-
-        trait :old do
-          published_at { 1.week.ago }
-        end
-      end
-    end
-  RUBY
-
-  include_examples 'autocorrect', bad, corrected
-end
diff --git a/spec/rubocop/cop/rspec/factory_bot/create_list_spec.rb b/spec/rubocop/cop/rspec/factory_bot/create_list_spec.rb
deleted file mode 100644
index 31e08eaa7..000000000
--- a/spec/rubocop/cop/rspec/factory_bot/create_list_spec.rb
+++ /dev/null
@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::FactoryBot::CreateList, :config do
-  subject(:cop) { described_class.new(config) }
-
-  let(:cop_config) do
-    { 'EnforcedStyle' => enforced_style }
-  end
-
-  context 'when EnforcedStyle is :create_list' do
-    let(:enforced_style) { :create_list }
-
-    it 'flags usage of n.times with no arguments' do
-      expect_offense(<<-RUBY)
-        3.times { create :user }
-        ^^^^^^^ Prefer create_list.
-      RUBY
-    end
-
-    it 'flags usage of n.times when FactoryGirl.create is used' do
-      expect_offense(<<-RUBY)
-        3.times { FactoryGirl.create :user }
-        ^^^^^^^ Prefer create_list.
-      RUBY
-    end
-
-    it 'flags usage of n.times when FactoryBot.create is used' do
-      expect_offense(<<-RUBY)
-        3.times { FactoryBot.create :user }
-        ^^^^^^^ Prefer create_list.
-      RUBY
-    end
-
-    it 'ignores create method of other object' do
-      expect_no_offenses(<<-RUBY)
-        3.times { SomeFactory.create :user }
-      RUBY
-    end
-
-    it 'ignores create in other block' do
-      expect_no_offenses(<<-RUBY)
-        allow(User).to receive(:create) { create :user }
-      RUBY
-    end
-
-    it 'ignores n.times with argument' do
-      expect_no_offenses(<<-RUBY)
-        3.times { |n| create :user, created_at: n.days.ago }
-      RUBY
-    end
-
-    it 'ignores n.times when there is no create call inside' do
-      expect_no_offenses(<<-RUBY)
-        3.times { do_something }
-      RUBY
-    end
-
-    it 'ignores n.times when there is other calls but create' do
-      expect_no_offenses(<<-RUBY)
-        used_passwords = []
-        3.times do
-          u = create :user
-          expect(used_passwords).not_to include(u.password)
-          used_passwords << u.password
-        end
-      RUBY
-    end
-
-    it 'flags FactoryGirl.create calls with a block' do
-      expect_offense(<<-RUBY)
-        3.times do
-        ^^^^^^^ Prefer create_list.
-          create(:user) { |user| create :account, user: user }
-        end
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     '5.times { create :user }',
-                     'create_list :user, 5'
-
-    include_examples 'autocorrect',
-                     '5.times { create(:user, :trait) }',
-                     'create_list(:user, 5, :trait)'
-
-    include_examples 'autocorrect',
-                     '5.times { create :user, :trait, key: val }',
-                     'create_list :user, 5, :trait, key: val'
-
-    include_examples 'autocorrect',
-                     '5.times { FactoryGirl.create :user }',
-                     'FactoryGirl.create_list :user, 5'
-
-    bad_code = <<-RUBY
-      3.times do
-        create(:user, :trait) { |user| create :account, user: user }
-      end
-    RUBY
-
-    good_code = <<-RUBY
-      create_list(:user, 3, :trait) { |user| create :account, user: user }
-    RUBY
-
-    include_examples 'autocorrect', bad_code, good_code
-
-    bad_code = <<-RUBY
-      3.times do
-        create(:user, :trait) do |user|
-          create :account, user: user
-          create :profile, user: user
-        end
-      end
-    RUBY
-
-    good_code = <<-RUBY
-      create_list(:user, 3, :trait) do |user|
-          create :account, user: user
-          create :profile, user: user
-      end
-    RUBY
-
-    include_examples 'autocorrect', bad_code, good_code
-  end
-
-  context 'when EnforcedStyle is :n_times' do
-    let(:enforced_style) { :n_times }
-
-    it 'flags usage of create_list' do
-      expect_offense(<<-RUBY)
-        create_list :user, 3
-        ^^^^^^^^^^^ Prefer 3.times.
-      RUBY
-    end
-
-    it 'flags usage of FactoryGirl.create_list' do
-      expect_offense(<<-RUBY)
-       FactoryGirl.create_list :user, 3
-                   ^^^^^^^^^^^ Prefer 3.times.
-      RUBY
-    end
-
-    it 'flags usage of FactoryGirl.create_list with a block' do
-      expect_offense(<<-RUBY)
-       FactoryGirl.create_list(:user, 3) { |user| user.points = rand(1000) }
-                   ^^^^^^^^^^^ Prefer 3.times.
-      RUBY
-    end
-
-    it 'ignores create method of other object' do
-      expect_no_offenses(<<-RUBY)
-        SomeFactory.create_list :user, 3
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     'create_list :user, 5',
-                     '5.times { create :user }'
-
-    include_examples 'autocorrect',
-                     'create_list(:user, 5, :trait)',
-                     '5.times { create(:user, :trait) }'
-
-    include_examples 'autocorrect',
-                     'create_list :user, 5, :trait, key: val',
-                     '5.times { create :user, :trait, key: val }'
-
-    include_examples 'autocorrect',
-                     'FactoryGirl.create_list :user, 5',
-                     '5.times { FactoryGirl.create :user }'
-  end
-end
diff --git a/spec/rubocop/cop/rspec/factory_bot/factory_class_name_spec.rb b/spec/rubocop/cop/rspec/factory_bot/factory_class_name_spec.rb
deleted file mode 100644
index f7a932d45..000000000
--- a/spec/rubocop/cop/rspec/factory_bot/factory_class_name_spec.rb
+++ /dev/null
@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::FactoryBot::FactoryClassName do
-  subject(:cop) { described_class.new }
-
-  context 'when passing block' do
-    it 'flags passing a class' do
-      expect_offense(<<~RUBY)
-        factory :foo, class: Foo do
-                             ^^^ Pass 'Foo' string instead of `Foo` constant.
-        end
-      RUBY
-
-      expect_correction(<<~RUBY)
-        factory :foo, class: 'Foo' do
-        end
-      RUBY
-    end
-
-    it 'flags passing a class from global namespace' do
-      expect_offense(<<~RUBY)
-        factory :foo, class: ::Foo do
-                             ^^^^^ Pass 'Foo' string instead of `Foo` constant.
-        end
-      RUBY
-
-      expect_correction(<<~RUBY)
-        factory :foo, class: '::Foo' do
-        end
-      RUBY
-    end
-
-    it 'flags passing a subclass' do
-      expect_offense(<<~RUBY)
-        factory :foo, class: Foo::Bar do
-                             ^^^^^^^^ Pass 'Foo::Bar' string instead of `Foo::Bar` constant.
-        end
-      RUBY
-
-      expect_correction(<<~RUBY)
-        factory :foo, class: 'Foo::Bar' do
-        end
-      RUBY
-    end
-
-    it 'ignores passing class name' do
-      expect_no_offenses(<<~RUBY)
-        factory :foo, class: 'Foo' do
-        end
-      RUBY
-    end
-
-    it 'ignores passing Hash' do
-      expect_no_offenses(<<~RUBY)
-        factory :foo, class: Hash do
-        end
-      RUBY
-    end
-
-    it 'ignores passing OpenStruct' do
-      expect_no_offenses(<<~RUBY)
-        factory :foo, class: OpenStruct do
-        end
-      RUBY
-    end
-  end
-
-  context 'when not passing block' do
-    it 'flags passing a class' do
-      expect_offense(<<~RUBY)
-        factory :foo, class: Foo
-                             ^^^ Pass 'Foo' string instead of `Foo` constant.
-      RUBY
-
-      expect_correction(<<~RUBY)
-        factory :foo, class: 'Foo'
-      RUBY
-    end
-
-    it 'ignores passing class name' do
-      expect_no_offenses(<<~RUBY)
-        factory :foo, class: 'Foo'
-      RUBY
-    end
-  end
-end
diff --git a/spec/rubocop/cop/rspec/file_path_spec.rb b/spec/rubocop/cop/rspec/file_path_spec.rb
deleted file mode 100644
index 389474553..000000000
--- a/spec/rubocop/cop/rspec/file_path_spec.rb
+++ /dev/null
@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::FilePath, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'registers an offense for a bad path' do
-    expect_offense(<<-RUBY, 'wrong_path_foo_spec.rb')
-      describe MyClass, 'foo' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a wrong class but a correct method' do
-    expect_offense(<<-RUBY, 'wrong_class_foo_spec.rb')
-      describe MyClass, '#foo' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a repeated .rb' do
-    expect_offense(<<-RUBY, 'my_class/foo_spec.rb.rb')
-      describe MyClass, '#foo' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a file missing a .rb' do
-    expect_offense(<<-RUBY, 'my_class/foo_specorb')
-      describe MyClass, '#foo' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a wrong class and highlights metadata' do
-    expect_offense(<<-RUBY, 'wrong_class_foo_spec.rb')
-      describe MyClass, '#foo', blah: :blah do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a wrong class name' do
-    expect_offense(<<-RUBY, 'wrong_class_spec.rb')
-      describe MyClass do; end
-      ^^^^^^^^^^^^^^^^ Spec path should end with `my_class*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a wrong class name with a symbol argument' do
-    expect_offense(<<-RUBY, 'wrong_class_spec.rb')
-      describe MyClass, :foo do; end
-      ^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*_spec.rb`.
-    RUBY
-  end
-
-  it 'registers an offense for a file missing _spec' do
-    expect_offense(<<-RUBY, 'user.rb')
-      describe User do; end
-      ^^^^^^^^^^^^^ Spec path should end with `user*_spec.rb`.
-    RUBY
-  end
-
-  it 'skips specs that do not describe a class / method' do
-    expect_no_offenses(<<-RUBY, 'some/class/spec.rb')
-      describe 'Test something' do; end
-    RUBY
-  end
-
-  it 'skips specs that do have multiple top level describes' do
-    expect_no_offenses(<<-RUBY, 'some/class/spec.rb')
-      describe MyClass, 'do_this' do; end
-      describe MyClass, 'do_that' do; end
-    RUBY
-  end
-
-  it 'checks class specs' do
-    expect_no_offenses(<<-RUBY, 'some/class_spec.rb')
-      describe Some::Class do; end
-    RUBY
-  end
-
-  it 'allows different parent directories' do
-    expect_no_offenses(<<-RUBY, 'parent_dir/some/class_spec.rb')
-      describe Some::Class do; end
-    RUBY
-  end
-
-  it 'handles CamelCaps class names' do
-    expect_no_offenses(<<-RUBY, 'my_class_spec.rb')
-      describe MyClass do; end
-    RUBY
-  end
-
-  it 'handles ACRONYMClassNames' do
-    expect_no_offenses(<<-RUBY, 'abc_one/two_spec.rb')
-      describe ABCOne::Two do; end
-    RUBY
-  end
-
-  it 'handles ALLCAPS class names' do
-    expect_no_offenses(<<-RUBY, 'allcaps_spec.rb')
-      describe ALLCAPS do; end
-    RUBY
-  end
-
-  it 'handles alphanumeric class names' do
-    expect_no_offenses(<<-RUBY, 'ipv4_and_ipv6_spec.rb')
-      describe IPV4AndIPV6 do; end
-    RUBY
-  end
-
-  it 'checks instance methods' do
-    expect_no_offenses(<<-RUBY, 'some/class/inst_spec.rb')
-      describe Some::Class, '#inst' do; end
-    RUBY
-  end
-
-  it 'checks class methods' do
-    expect_no_offenses(<<-RUBY, 'some/class/inst_spec.rb')
-      describe Some::Class, '.inst' do; end
-    RUBY
-  end
-
-  it 'allows flat hierarchies for instance methods' do
-    expect_no_offenses(<<-RUBY, 'some/class_inst_spec.rb')
-      describe Some::Class, '#inst' do; end
-    RUBY
-  end
-
-  it 'allows flat hierarchies for class methods' do
-    expect_no_offenses(<<-RUBY, 'some/class_inst_spec.rb')
-      describe Some::Class, '.inst' do; end
-    RUBY
-  end
-
-  it 'allows subdirs for instance methods' do
-    filename = 'some/class/instance_methods/inst_spec.rb'
-    expect_no_offenses(<<-RUBY, filename)
-      describe Some::Class, '#inst' do; end
-    RUBY
-  end
-
-  it 'allows subdirs for class methods' do
-    filename = 'some/class/class_methods/inst_spec.rb'
-    expect_no_offenses(<<-RUBY, filename)
-      describe Some::Class, '.inst' do; end
-    RUBY
-  end
-
-  it 'ignores non-alphanumeric characters' do
-    expect_no_offenses(<<-RUBY, 'some/class/pred_spec.rb')
-      describe Some::Class, '#pred?' do; end
-    RUBY
-  end
-
-  it 'allows bang method' do
-    expect_no_offenses(<<-RUBY, 'some/class/bang_spec.rb')
-      describe Some::Class, '#bang!' do; end
-    RUBY
-  end
-
-  it 'allows flexibility with predicates' do
-    filename = 'some/class/thing_predicate_spec.rb'
-    expect_no_offenses(<<-RUBY, filename)
-      describe Some::Class, '#thing?' do; end
-    RUBY
-  end
-
-  it 'allows flexibility with operators' do
-    filename = 'my_little_class/spaceship_operator_spec.rb'
-    expect_no_offenses(<<-RUBY, filename)
-      describe MyLittleClass, '#<=>' do; end
-    RUBY
-  end
-
-  context 'when configured with CustomTransform' do
-    let(:cop_config) { { 'CustomTransform' => { 'FooFoo' => 'foofoo' } } }
-
-    it 'respects custom module name transformation' do
-      expect_no_offenses(<<-RUBY, 'foofoo/some/class/bar_spec.rb')
-        describe FooFoo::Some::Class, '#bar' do; end
-      RUBY
-    end
-
-    it 'ignores routing specs' do
-      expect_no_offenses(<<-RUBY, 'foofoo/some/class/bar_spec.rb')
-        describe MyController, "#foo", type: :routing do; end
-      RUBY
-    end
-  end
-
-  context 'when configured with IgnoreMethods' do
-    let(:cop_config) { { 'IgnoreMethods' => true } }
-
-    it 'does not care about the described method' do
-      expect_no_offenses(<<-RUBY, 'my_class_spec.rb')
-        describe MyClass, '#look_here_a_method' do; end
-      RUBY
-    end
-  end
-end
diff --git a/spec/rubocop/cop/rspec/focus_spec.rb b/spec/rubocop/cop/rspec/focus_spec.rb
index 250912860..83ceaf15e 100644
--- a/spec/rubocop/cop/rspec/focus_spec.rb
+++ b/spec/rubocop/cop/rspec/focus_spec.rb
@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::Focus do
-  subject(:cop) { described_class.new }
-
-  # rubocop:disable RSpec/ExampleLength
   it 'flags all rspec example blocks with that include `focus: true`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       example 'test', meta: true, focus: true do; end
                                   ^^^^^^^^^^^ Focused spec found.
       xit 'test', meta: true, focus: true do; end
@@ -40,11 +37,37 @@
                                     ^^^^^^^^^^^ Focused spec found.
       pending 'test', meta: true, focus: true do; end
                                   ^^^^^^^^^^^ Focused spec found.
+      shared_examples 'test', meta: true, focus: true do; end
+                                          ^^^^^^^^^^^ Focused spec found.
+      shared_context 'test', meta: true, focus: true do; end
+                                         ^^^^^^^^^^^ Focused spec found.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      example 'test', meta: true do; end
+      xit 'test', meta: true do; end
+      describe 'test', meta: true do; end
+      RSpec.describe 'test', meta: true do; end
+      it 'test', meta: true do; end
+      xspecify 'test', meta: true do; end
+      specify 'test', meta: true do; end
+      example_group 'test', meta: true do; end
+      scenario 'test', meta: true do; end
+      xexample 'test', meta: true do; end
+      xdescribe 'test', meta: true do; end
+      context 'test', meta: true do; end
+      xcontext 'test', meta: true do; end
+      feature 'test', meta: true do; end
+      xfeature 'test', meta: true do; end
+      xscenario 'test', meta: true do; end
+      pending 'test', meta: true do; end
+      shared_examples 'test', meta: true do; end
+      shared_context 'test', meta: true do; end
     RUBY
   end
 
   it 'flags all rspec example blocks that include `:focus`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       example_group 'test', :focus do; end
                             ^^^^^^ Focused spec found.
       feature 'test', :focus do; end
@@ -79,12 +102,37 @@
                  ^^^^^^ Focused spec found.
       pending 'test', :focus do; end
                       ^^^^^^ Focused spec found.
+      shared_examples 'test', :focus do; end
+                              ^^^^^^ Focused spec found.
+      shared_context 'test', :focus do; end
+                             ^^^^^^ Focused spec found.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      example_group 'test' do; end
+      feature 'test' do; end
+      xexample 'test' do; end
+      xdescribe 'test' do; end
+      xscenario 'test' do; end
+      specify 'test' do; end
+      example 'test' do; end
+      xfeature 'test' do; end
+      xspecify 'test' do; end
+      scenario 'test' do; end
+      describe 'test' do; end
+      RSpec.describe 'test' do; end
+      xit 'test' do; end
+      context 'test' do; end
+      xcontext 'test' do; end
+      it 'test' do; end
+      pending 'test' do; end
+      shared_examples 'test' do; end
+      shared_context 'test' do; end
     RUBY
   end
-  # rubocop:enable RSpec/ExampleLength
 
   it 'does not flag unfocused specs' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       xcontext      'test' do; end
       xscenario     'test' do; end
       xspecify      'test' do; end
@@ -100,26 +148,33 @@
       it            'test' do; end
       example_group 'test' do; end
       xdescribe     'test' do; end
+      shared_examples 'test' do; end
+      shared_context  'test' do; end
     RUBY
   end
 
-  it 'does not flag a method that is focused twice' do
-    expect_offense(<<-RUBY)
+  it 'flags a method that is focused twice' do
+    expect_offense(<<~RUBY)
       fit "foo", :focus do
       ^^^^^^^^^^^^^^^^^ Focused spec found.
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      it "foo" do
+      end
+    RUBY
   end
 
   it 'ignores non-rspec code with :focus blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       some_method "foo", focus: true do
       end
     RUBY
   end
 
   it 'flags focused block types' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       fdescribe 'test' do; end
       ^^^^^^^^^^^^^^^^ Focused spec found.
       RSpec.fdescribe 'test' do; end
@@ -139,12 +194,67 @@
       focus 'test' do; end
       ^^^^^^^^^^^^ Focused spec found.
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'test' do; end
+      RSpec.describe 'test' do; end
+      feature 'test' do; end
+      context 'test' do; end
+      it 'test' do; end
+      scenario 'test' do; end
+      example 'test' do; end
+      specify 'test' do; end
+      focus 'test' do; end
+    RUBY
   end
 
   it 'flags rspec example blocks that include `:focus` preceding a hash' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'test', :focus, js: true do; end
                        ^^^^^^ Focused spec found.
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'test', js: true do; end
+    RUBY
+  end
+
+  it 'ignores with chained method calls' do
+    expect_no_offenses(<<~RUBY)
+      let(:fit) { Tax.federal_income_tax }
+      let(:fit_id) { fit.id }
+    RUBY
+  end
+
+  it 'ignores when inside define method' do
+    expect_no_offenses(<<~RUBY)
+      context 'test' do
+        def foo
+          fdescribe 'test'
+          ffeature 'test'
+          fcontext 'test'
+          fit 'test'
+          fscenario 'test'
+          fexample 'test'
+          fspecify 'test'
+          focus 'test'
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores when inside define singleton method' do
+    expect_no_offenses(<<~RUBY)
+      def self.foo
+        fdescribe 'test'
+        ffeature 'test'
+        fcontext 'test'
+        fit 'test'
+        fscenario 'test'
+        fexample 'test'
+        fspecify 'test'
+        focus 'test'
+      end
+    RUBY
   end
 end
diff --git a/spec/rubocop/cop/rspec/hook_argument_spec.rb b/spec/rubocop/cop/rspec/hook_argument_spec.rb
index e07c051b1..6a7fbd6e8 100644
--- a/spec/rubocop/cop/rspec/hook_argument_spec.rb
+++ b/spec/rubocop/cop/rspec/hook_argument_spec.rb
@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::HookArgument, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::HookArgument do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
 
   shared_examples 'ignored hooks' do
     it 'ignores :context and :suite' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before(:suite) { true }
         after(:suite) { true }
         before(:context) { true }
@@ -18,156 +16,277 @@
     end
 
     it 'ignores hooks with more than one argument' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before(:each, :something_custom) { true }
       RUBY
     end
 
     it 'ignores non-rspec hooks' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         setup(:each) { true }
       RUBY
     end
   end
 
-  shared_examples 'hook autocorrect' do |output|
-    include_examples 'autocorrect', 'before(:each) { }', output
-    include_examples 'autocorrect', 'before(:example) { }', output
-    include_examples 'autocorrect', 'before { }', output
-
-    include_examples 'autocorrect', 'config.before(:each) { }',
-                     'config.' + output
-    include_examples 'autocorrect', 'config.before(:example) { }',
-                     'config.' + output
-    include_examples 'autocorrect', 'config.before { }',
-                     'config.' + output
-  end
-
   shared_examples 'an example hook' do
-    include_examples 'ignored hooks'
-    include_examples 'detects style', 'before(:each) { foo }', 'each'
-    include_examples 'detects style', 'before(:example) { foo }', 'example'
-    include_examples 'detects style', 'before { foo }', 'implicit'
+    it_behaves_like 'ignored hooks'
+    it_behaves_like 'detects style', 'before(:each) { foo }', 'each'
+    it_behaves_like 'detects style', 'before(:example) { foo }', 'example'
+    it_behaves_like 'detects style', 'before { foo }', 'implicit'
   end
 
   context 'when EnforcedStyle is :implicit' do
     let(:enforced_style) { :implicit }
 
     it 'detects :each for hooks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before(:each) { true }
         ^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
-        after(:each)  { true }
+        after(:each) { true }
         ^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
         around(:each) { true }
         ^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
-        config.after(:each)  { true }
+        config.after(:each) { true }
         ^^^^^^^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before { true }
+        after { true }
+        around { true }
+        config.after { true }
+      RUBY
     end
 
     it 'detects :example for hooks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before(:example) { true }
         ^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
-        after(:example)  { true }
+        after(:example) { true }
         ^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
         around(:example) { true }
         ^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
         config.before(:example) { true }
         ^^^^^^^^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before { true }
+        after { true }
+        around { true }
+        config.before { true }
+      RUBY
     end
 
     it 'does not flag hooks without default scopes' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before { true }
         after { true }
+        around { true }
         config.before { true }
       RUBY
     end
 
-    include_examples 'an example hook'
-    include_examples 'hook autocorrect', 'before { }'
+    it_behaves_like 'an example hook'
+
+    context 'when Ruby 2.7', :ruby27 do
+      it 'detects :each for hooks' do
+        expect_offense(<<~RUBY)
+          around(:each) { _1 }
+          ^^^^^^^^^^^^^ Omit the default `:each` argument for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around { _1 }
+        RUBY
+      end
+
+      it 'detects :example for hooks' do
+        expect_offense(<<~RUBY)
+          around(:example) { _1 }
+          ^^^^^^^^^^^^^^^^ Omit the default `:example` argument for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around { _1 }
+        RUBY
+      end
+
+      it 'does not flag hooks without default scopes' do
+        expect_no_offenses(<<~RUBY)
+          around { _1 }
+        RUBY
+      end
+    end
   end
 
   context 'when EnforcedStyle is :each' do
     let(:enforced_style) { :each }
 
-    it 'detects :each for hooks' do
-      expect_no_offenses(<<-RUBY)
+    it 'does not flag :each for hooks' do
+      expect_no_offenses(<<~RUBY)
         before(:each) { true }
-        after(:each)  { true }
+        after(:each) { true }
         around(:each) { true }
         config.before(:each) { true }
       RUBY
     end
 
     it 'detects :example for hooks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before(:example) { true }
         ^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
-        after(:example)  { true }
+        after(:example) { true }
         ^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
         around(:example) { true }
         ^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
         config.before(:example) { true }
         ^^^^^^^^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before(:each) { true }
+        after(:each) { true }
+        around(:each) { true }
+        config.before(:each) { true }
+      RUBY
     end
 
     it 'detects hooks without default scopes' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before { true }
         ^^^^^^ Use `:each` for RSpec hooks.
         after { true }
         ^^^^^ Use `:each` for RSpec hooks.
+        around { true }
+        ^^^^^^ Use `:each` for RSpec hooks.
         config.before { true }
                ^^^^^^ Use `:each` for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before(:each) { true }
+        after(:each) { true }
+        around(:each) { true }
+        config.before(:each) { true }
+      RUBY
     end
 
-    include_examples 'an example hook'
-    include_examples 'hook autocorrect', 'before(:each) { }'
+    it_behaves_like 'an example hook'
+
+    context 'when Ruby 2.7', :ruby27 do
+      it 'does not flag :each for hooks' do
+        expect_no_offenses(<<~RUBY)
+          around(:each) { _1 }
+        RUBY
+      end
+
+      it 'detects :example for hooks' do
+        expect_offense(<<~RUBY)
+          around(:example) { _1 }
+          ^^^^^^^^^^^^^^^^ Use `:each` for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around(:each) { _1 }
+        RUBY
+      end
+
+      it 'detects hooks without default scopes' do
+        expect_offense(<<~RUBY)
+          around { _1 }
+          ^^^^^^ Use `:each` for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around(:each) { _1 }
+        RUBY
+      end
+    end
   end
 
   context 'when EnforcedStyle is :example' do
     let(:enforced_style) { :example }
 
-    it 'detects :example for hooks' do
-      expect_no_offenses(<<-RUBY)
+    it 'does not flag :example for hooks' do
+      expect_no_offenses(<<~RUBY)
         before(:example) { true }
-        after(:example)  { true }
+        after(:example) { true }
         around(:example) { true }
         config.before(:example) { true }
       RUBY
     end
 
     it 'detects :each for hooks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before(:each) { true }
         ^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
-        after(:each)  { true }
+        after(:each) { true }
         ^^^^^^^^^^^^ Use `:example` for RSpec hooks.
         around(:each) { true }
         ^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
         config.before(:each) { true }
         ^^^^^^^^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before(:example) { true }
+        after(:example) { true }
+        around(:example) { true }
+        config.before(:example) { true }
+      RUBY
     end
 
-    it 'does not flag hooks without default scopes' do
-      expect_offense(<<-RUBY)
+    it 'detects hooks without default scopes' do
+      expect_offense(<<~RUBY)
         before { true }
         ^^^^^^ Use `:example` for RSpec hooks.
         after { true }
         ^^^^^ Use `:example` for RSpec hooks.
+        around { true }
+        ^^^^^^ Use `:example` for RSpec hooks.
         config.before { true }
                ^^^^^^ Use `:example` for RSpec hooks.
       RUBY
+
+      expect_correction(<<~RUBY)
+        before(:example) { true }
+        after(:example) { true }
+        around(:example) { true }
+        config.before(:example) { true }
+      RUBY
     end
 
-    include_examples 'an example hook'
-    include_examples 'hook autocorrect', 'before(:example) { }'
+    it_behaves_like 'an example hook'
+
+    context 'when Ruby 2.7', :ruby27 do
+      it 'does not flag :example for hooks' do
+        expect_no_offenses(<<~RUBY)
+          around(:example) { _1 }
+        RUBY
+      end
+
+      it 'detects :each for hooks' do
+        expect_offense(<<~RUBY)
+          around(:each) { _1 }
+          ^^^^^^^^^^^^^ Use `:example` for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around(:example) { _1 }
+        RUBY
+      end
+
+      it 'detects hooks without default scopes' do
+        expect_offense(<<~RUBY)
+          around { _1 }
+          ^^^^^^ Use `:example` for RSpec hooks.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          around(:example) { _1 }
+        RUBY
+      end
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/hooks_before_examples_spec.rb b/spec/rubocop/cop/rspec/hooks_before_examples_spec.rb
index c105485ff..180041b03 100644
--- a/spec/rubocop/cop/rspec/hooks_before_examples_spec.rb
+++ b/spec/rubocop/cop/rspec/hooks_before_examples_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::HooksBeforeExamples do
-  subject(:cop) { described_class.new }
-
   it 'flags `before` after `it`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         it { is_expected.to be_after_before_hook }
         before { setup }
@@ -12,7 +10,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         before { setup }
         it { is_expected.to be_after_before_hook }
@@ -21,7 +19,7 @@
   end
 
   it 'flags `before` after `context`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         context 'a context' do
           it { is_expected.to be_after_before_hook }
@@ -32,7 +30,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         before { setup }
         context 'a context' do
@@ -44,7 +42,7 @@
   end
 
   it 'flags `before` after `include_examples`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         include_examples('should be after before-hook')
 
@@ -53,7 +51,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         before { setup }
         include_examples('should be after before-hook')
@@ -63,7 +61,7 @@
   end
 
   it 'flags `after` after an example' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         it { is_expected.to be_after_after_hook }
         after { cleanup }
@@ -71,7 +69,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         after { cleanup }
         it { is_expected.to be_after_after_hook }
@@ -80,7 +78,7 @@
   end
 
   it 'flags scoped hook after an example' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         it { is_expected.to be_after_before_hook }
         before(:each) { cleanup }
@@ -88,7 +86,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         before(:each) { cleanup }
         it { is_expected.to be_after_before_hook }
@@ -96,8 +94,29 @@
     RUBY
   end
 
+  it 'works with comments' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it { is_expected.to be_after_before_hook } # h
+        # setup the system
+        # with multiline comment
+        before { setup } # some setup
+        ^^^^^^^^^^^^^^^^ Move `before` above the examples in the group.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        # setup the system
+        # with multiline comment
+        before { setup } # some setup
+        it { is_expected.to be_after_before_hook } # h
+      end
+    RUBY
+  end
+
   it 'does not flag hooks before the examples' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         before(:each) { setup }
         after(:each) { cleanup }
@@ -114,7 +133,7 @@
   end
 
   it 'does not flag `before` in a nested context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         before { setup }
 
@@ -129,7 +148,7 @@
   end
 
   it 'allows inclusion of context before hooks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         include_context 'special user'
 
@@ -139,7 +158,7 @@
   end
 
   it 'ignores single-line example blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         include_examples 'special user' do
           before { setup }
@@ -147,4 +166,65 @@
       end
     RUBY
   end
+
+  context 'when Ruby 2.7', :ruby27 do
+    it 'flags `around` after `it`' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          it { is_expected.to be_after_around_hook }
+          around { _1 }
+          ^^^^^^^^^^^^^ Move `around` above the examples in the group.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          around { _1 }
+          it { is_expected.to be_after_around_hook }
+        end
+      RUBY
+    end
+
+    it 'flags `around` after `context`' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          context 'a context' do
+            it { is_expected.to be_after_around_hook }
+          end
+
+          around { _1 }
+          ^^^^^^^^^^^^^ Move `around` above the examples in the group.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          around { _1 }
+          context 'a context' do
+            it { is_expected.to be_after_around_hook }
+          end
+
+        end
+      RUBY
+    end
+
+    it 'flags `around` after `include_examples`' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          include_examples('should be after around-hook')
+
+          around { _1 }
+          ^^^^^^^^^^^^^ Move `around` above the examples in the group.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe User do
+          around { _1 }
+          include_examples('should be after around-hook')
+
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/identical_equality_assertion_spec.rb b/spec/rubocop/cop/rspec/identical_equality_assertion_spec.rb
new file mode 100644
index 000000000..0524f4d20
--- /dev/null
+++ b/spec/rubocop/cop/rspec/identical_equality_assertion_spec.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::IdenticalEqualityAssertion do
+  it 'registers an offense when using identical expressions with `eq`' do
+    expect_offense(<<~RUBY)
+      expect(foo.bar).to eq(foo.bar)
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'registers an offense when using identical expressions with `eql`' do
+    expect_offense(<<~RUBY)
+      expect(foo.bar.baz).to eql(foo.bar.baz)
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'registers an offense for trivial constants' do
+    expect_offense(<<~RUBY)
+      expect(42).to eq(42)
+      ^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'registers an offense for complex constants' do
+    expect_offense(<<~RUBY)
+      expect({a: 1, b: :b}).to eql({a: 1, b: :b})
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'registers an offense for identical expression with be' do
+    expect_offense(<<~RUBY)
+      expect(foo.bar).to be(foo.bar)
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'registers an offense for identical expression with be ==' do
+    expect_offense(<<~RUBY)
+      expect(foo.bar).to be == foo.bar
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Identical expressions on both sides of the equality may indicate a flawed test.
+    RUBY
+  end
+
+  it 'does not register offense for different expressions' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo.bar).to eq(bar.foo)
+    RUBY
+  end
+
+  it 'checks for whole expression' do
+    expect_no_offenses(<<~RUBY)
+      expect(Foo.new(1).foo).to eql(Foo.new(2).bar)
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/implicit_block_expectation_spec.rb b/spec/rubocop/cop/rspec/implicit_block_expectation_spec.rb
index 10a1262ad..95593b531 100644
--- a/spec/rubocop/cop/rspec/implicit_block_expectation_spec.rb
+++ b/spec/rubocop/cop/rspec/implicit_block_expectation_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ImplicitBlockExpectation do
-  subject(:cop) { described_class.new }
-
   it 'flags lambda in subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject { -> { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -14,7 +12,7 @@
   end
 
   it 'ignores non-lambda subject' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe do
         subject { 'normal' }
         it { is_expected.to eq(something) }
@@ -23,7 +21,7 @@
   end
 
   it 'flags lambda in subject!' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject! { -> { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -33,7 +31,7 @@
   end
 
   it 'flags literal lambda' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject! { lambda { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -43,7 +41,7 @@
   end
 
   it 'flags proc' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject! { proc { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -53,7 +51,7 @@
   end
 
   it 'flags Proc.new' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject! { Proc.new { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -63,7 +61,7 @@
   end
 
   it 'flags named subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject(:name) { -> { boom } }
         it { is_expected.to change { something }.to(new_value) }
@@ -73,7 +71,7 @@
   end
 
   it 'flags when subject is defined in the outer example group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject { -> { boom } }
         context do
@@ -85,7 +83,7 @@
   end
 
   it 'ignores normal local subject' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe do
         subject { -> { boom } }
         context do
@@ -97,7 +95,7 @@
   end
 
   it 'ignores named subject with deeply nested lambda' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe do
         subject { {hash: -> { boom }} }
         it { is_expected.to be(something) }
@@ -106,7 +104,7 @@
   end
 
   it 'flags with `should` as implicit subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject { -> { boom } }
         it { should change { something }.to(new_value) }
@@ -116,7 +114,7 @@
   end
 
   it 'flags with `should_not` as implicit subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
         subject { -> { boom } }
         it { should_not change { something }.to(new_value) }
@@ -126,7 +124,7 @@
   end
 
   it 'ignores when there is no subject defined' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       shared_examples 'subject is defined somewhere else' do
         it { is_expected.to change { something }.to(new_value) }
       end
diff --git a/spec/rubocop/cop/rspec/implicit_expect_spec.rb b/spec/rubocop/cop/rspec/implicit_expect_spec.rb
index 876a090fa..143b37ac9 100644
--- a/spec/rubocop/cop/rspec/implicit_expect_spec.rb
+++ b/spec/rubocop/cop/rspec/implicit_expect_spec.rb
@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ImplicitExpect, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ImplicitExpect do
   context 'when EnforcedStyle is is_expected' do
     let(:cop_config) do
       { 'EnforcedStyle' => 'is_expected' }
     end
 
     it 'flags it { should }' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { should be_truthy }
              ^^^^^^ Prefer `is_expected.to` over `should`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { is_expected.to be_truthy }
       RUBY
     end
 
     it 'flags it { should_not }' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { should_not be_truthy }
              ^^^^^^^^^^ Prefer `is_expected.to_not` over `should_not`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { is_expected.to_not be_truthy }
       RUBY
     end
@@ -42,7 +40,7 @@
       expect_no_offenses('it { is_expected.not_to be_truthy }')
     end
 
-    include_examples 'detects style', 'it { should be_truthy }', 'should'
+    it_behaves_like 'detects style', 'it { should be_truthy }', 'should'
   end
 
   context 'when EnforcedStyle is should' do
@@ -51,34 +49,34 @@
     end
 
     it 'flags it { is_expected.to }' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { is_expected.to be_truthy }
              ^^^^^^^^^^^^^^ Prefer `should` over `is_expected.to`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { should be_truthy }
       RUBY
     end
 
     it 'flags it { is_expected.to_not }' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { is_expected.to_not be_truthy }
              ^^^^^^^^^^^^^^^^^^ Prefer `should_not` over `is_expected.to_not`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { should_not be_truthy }
       RUBY
     end
 
     it 'flags it { is_expected.not_to }' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { is_expected.not_to be_truthy }
              ^^^^^^^^^^^^^^^^^^ Prefer `should_not` over `is_expected.not_to`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { should_not be_truthy }
       RUBY
     end
@@ -91,12 +89,12 @@
       expect_no_offenses('it { should_not be_truthy }')
     end
 
-    include_examples 'detects style',
-                     'it { is_expected.to be_truthy }',
-                     'is_expected'
+    it_behaves_like 'detects style',
+                    'it { is_expected.to be_truthy }',
+                    'is_expected'
 
-    include_examples 'detects style',
-                     'it { should be_truthy }',
-                     'should'
+    it_behaves_like 'detects style',
+                    'it { should be_truthy }',
+                    'should'
   end
 end
diff --git a/spec/rubocop/cop/rspec/implicit_subject_spec.rb b/spec/rubocop/cop/rspec/implicit_subject_spec.rb
index b1c04e388..1e9834a0c 100644
--- a/spec/rubocop/cop/rspec/implicit_subject_spec.rb
+++ b/spec/rubocop/cop/rspec/implicit_subject_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ImplicitSubject, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ImplicitSubject do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
@@ -11,14 +9,14 @@
     let(:enforced_style) { 'single_line_only' }
 
     it 'flags `is_expected` in multi-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it 'expect subject to be used' do
           is_expected.to be_good
           ^^^^^^^^^^^ Don't use implicit subject.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it 'expect subject to be used' do
           expect(subject).to be_good
         end
@@ -26,7 +24,7 @@
     end
 
     it 'allows `is_expected` inside `its` block, in multi-line examples' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         its(:quality) do
           is_expected.to be :high
         end
@@ -34,7 +32,7 @@
     end
 
     it 'flags `should` in multi-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it 'expect subject to be used' do
           should be_good
           ^^^^^^^^^^^^^^ Don't use implicit subject.
@@ -43,7 +41,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it 'expect subject to be used' do
           expect(subject).to be_good
           expect(subject).not_to be_bad
@@ -52,19 +50,19 @@
     end
 
     it 'allows `is_expected` in single-line examples' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it { is_expected.to be_good }
       RUBY
     end
 
     it 'allows `should` in single-line examples' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it { should be_good }
       RUBY
     end
 
     it 'does not flag methods called is_expected and should' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it 'uses some similar sounding methods' do
           expect(baz).to receive(:is_expected)
           baz.is_expected
@@ -74,14 +72,14 @@
     end
 
     it 'detects usage of `is_expected` inside helper methods' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         def permits(actions)
           actions.each { |action| is_expected.to permit_action(action) }
                                   ^^^^^^^^^^^ Don't use implicit subject.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         def permits(actions)
           actions.each { |action| expect(subject).to permit_action(action) }
         end
@@ -93,7 +91,7 @@ def permits(actions)
     let(:enforced_style) { 'single_statement_only' }
 
     it 'allows `is_expected` in multi-line example with single statement' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it 'expect subject to be used' do
           is_expected.to be_good
         end
@@ -101,7 +99,7 @@ def permits(actions)
     end
 
     it 'flags `is_expected` in multi-statement examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it 'expect subject to be used' do
           subject.age = 18
           is_expected.to be_valid
@@ -109,27 +107,41 @@ def permits(actions)
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it 'expect subject to be used' do
           subject.age = 18
           expect(subject).to be_valid
         end
       RUBY
     end
+
+    it 'does not flag is_expected in describe blocks (non-example contexts)' do
+      expect_no_offenses(<<~RUBY)
+        describe 'something' do
+          is_expected.to be_valid
+        end
+      RUBY
+    end
+
+    it 'does not flag an empty example' do
+      expect_no_offenses(<<~RUBY)
+        it('is valid') { }
+      RUBY
+    end
   end
 
   context 'with EnforcedStyle `disallow`' do
     let(:enforced_style) { 'disallow' }
 
     it 'flags `is_expected` in multi-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it 'expect subject to be used' do
           is_expected.to be_good
           ^^^^^^^^^^^ Don't use implicit subject.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it 'expect subject to be used' do
           expect(subject).to be_good
         end
@@ -137,18 +149,18 @@ def permits(actions)
     end
 
     it 'flags `is_expected` in single-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { is_expected.to be_good }
              ^^^^^^^^^^^ Don't use implicit subject.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { expect(subject).to be_good }
       RUBY
     end
 
     it 'flags `should` in multi-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it 'expect subject to be used' do
           should be_good
           ^^^^^^^^^^^^^^ Don't use implicit subject.
@@ -157,7 +169,7 @@ def permits(actions)
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it 'expect subject to be used' do
           expect(subject).to be_good
           expect(subject).not_to be_bad
@@ -166,23 +178,91 @@ def permits(actions)
     end
 
     it 'flags `should` in single-line examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { should be_good }
              ^^^^^^^^^^^^^^ Don't use implicit subject.
         it { should_not be_bad }
              ^^^^^^^^^^^^^^^^^ Don't use implicit subject.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { expect(subject).to be_good }
         it { expect(subject).not_to be_bad }
       RUBY
     end
 
     it 'allows `is_expected` inside `its` block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         its(:quality) { is_expected.to be :high }
       RUBY
     end
   end
+
+  context 'with EnforcedStyle `require_implicit`' do
+    let(:enforced_style) { 'require_implicit' }
+
+    context 'with `is_expected`' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          it { is_expected.to be_good }
+        RUBY
+      end
+    end
+
+    context 'with `expect { subject }`' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          it { expect { subject }.to change(goodness, :count) }
+        RUBY
+      end
+    end
+
+    context 'with `its`' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          its(:quality) { is_expected.to be(:high) }
+        RUBY
+      end
+    end
+
+    context 'with named subject' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          subject(:instance) { described_class.new }
+
+          it { expect(instance).to be_good }
+        RUBY
+      end
+    end
+
+    context 'with `expect(subject)` in one-line' do
+      it 'registers and autocorrects an offense' do
+        expect_offense(<<~RUBY)
+          it { expect(subject).to be_good }
+               ^^^^^^^^^^^^^^^ Don't use explicit subject.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          it { is_expected.to be_good }
+        RUBY
+      end
+    end
+
+    context 'with `expect(subject)` in multi-lines' do
+      it 'registers and autocorrects an offense' do
+        expect_offense(<<~RUBY)
+          it do
+            expect(subject).to be_good
+            ^^^^^^^^^^^^^^^ Don't use explicit subject.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          it do
+            is_expected.to be_good
+          end
+        RUBY
+      end
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/include_examples_spec.rb b/spec/rubocop/cop/rspec/include_examples_spec.rb
new file mode 100644
index 000000000..f0ff6e77e
--- /dev/null
+++ b/spec/rubocop/cop/rspec/include_examples_spec.rb
@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::IncludeExamples, :config do
+  it 'registers an offense and corrects for `include_examples`' do
+    expect_offense(<<~RUBY)
+      include_examples 'examples'
+      ^^^^^^^^^^^^^^^^ Prefer `it_behaves_like` over `include_examples`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it_behaves_like 'examples'
+    RUBY
+  end
+
+  it 'does not register an offense for `it_behaves_like`' do
+    expect_no_offenses(<<~RUBY)
+      it_behaves_like 'examples'
+    RUBY
+  end
+
+  it 'does not register an offense for `it_should_behave_like`' do
+    expect_no_offenses(<<~RUBY)
+      it_should_behave_like 'examples'
+    RUBY
+  end
+
+  it 'does not register an offense for `include_context`' do
+    expect_no_offenses(<<~RUBY)
+      include_context 'context'
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/indexed_let_spec.rb b/spec/rubocop/cop/rspec/indexed_let_spec.rb
new file mode 100644
index 000000000..9f6cdbf4f
--- /dev/null
+++ b/spec/rubocop/cop/rspec/indexed_let_spec.rb
@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::IndexedLet do
+  let(:max) { 1 }
+  let(:allowed_patterns) { [] }
+  let(:allowed_identifiers) { [] }
+  let(:cop_config) do
+    {
+      'Max' => max,
+      'AllowedIdentifiers' => allowed_identifiers,
+      'AllowedPatterns' => allowed_patterns
+    }
+  end
+
+  it 'flags repeated symbol names' do
+    expect_offense(<<~RUBY)
+      describe SomeService do
+        let(:item_1) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let(:item_2) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'flags repeated string names' do
+    expect_offense(<<~RUBY)
+      describe SomeService do
+        let("item_1") { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let("item_2") { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'flags repeated names without underscores' do
+    expect_offense(<<~RUBY)
+      describe SomeService do
+        let(:item1) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let(:item2) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'flags repeated names with blockpasses' do
+    expect_offense(<<~RUBY)
+      describe SomeService do
+        let(:item_1, &block)
+        ^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let(:item_2, &block)
+        ^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'not flags indexed lets inside nested contexts' do
+    expect_no_offenses(<<~RUBY)
+      describe SomeService do
+        let(:item_1) { create(:item) }
+
+        context "some context" do
+          let(:item_2) { create(:item) }
+        end
+      end
+    RUBY
+  end
+
+  it 'flags names with two numbers' do
+    expect_offense(<<~RUBY)
+      context SomeService do
+        let(:user_1_item_1) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let(:user_1_item_2) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let(:user_2_item_1) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'ignores names with an index-like and a suffix' do
+    expect_no_offenses(<<~RUBY)
+      context SomeService do
+        let(:user_7_day_average) { 700 }
+        let(:user_30_day_average) { 3000 }
+      end
+    RUBY
+  end
+
+  it 'not flags which have different prefixes' do
+    expect_no_offenses(<<~RUBY)
+      describe SomeService do
+        let(:item_1) { create(:item) }
+        let(:foo_item_1) { create(:item) }
+      end
+    RUBY
+  end
+
+  it 'not flags item without index' do
+    expect_no_offenses(<<~RUBY)
+      describe SomeService do
+        let(:item) { create(:item) }
+        let(:item_1) { create(:item) }
+      end
+    RUBY
+  end
+
+  it 'flags mixed symbols and strings' do
+    expect_offense(<<~RUBY)
+      describe SomeService do
+        let(:item_1) { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `1` in its name. Please give it a meaningful name.
+        let("item_2") { create(:item) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ This `let` statement uses `2` in its name. Please give it a meaningful name.
+      end
+    RUBY
+  end
+
+  it 'not flags one indexed let because maximum not reached' do
+    expect_no_offenses(<<~RUBY)
+      describe SomeService do
+        let(:item_1) { create(:item) }
+      end
+    RUBY
+  end
+
+  context 'when Max is 2' do
+    let(:max) { 2 }
+
+    it 'not flags one indexed let because maximum not reached' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeService do
+          let(:item_1) { create(:item) }
+          let(:item_2) { create(:item) }
+        end
+      RUBY
+    end
+  end
+
+  context 'when AllowedIdentifiers is set' do
+    let(:allowed_identifiers) { %w[item_1 item_2] }
+
+    it 'not flags allowed indexed let' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeService do
+          let(:item_1) { create(:item) }
+          let(:item_2) { create(:item) }
+        end
+      RUBY
+    end
+  end
+
+  context 'when AllowedPatterns is set' do
+    let(:allowed_patterns) { %w[item] }
+
+    it 'not flags allowed indexed let' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeService do
+          let(:item_1) { create(:item) }
+          let(:item_2) { create(:item) }
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/instance_spy_spec.rb b/spec/rubocop/cop/rspec/instance_spy_spec.rb
index 7b240a09a..94f0d360f 100644
--- a/spec/rubocop/cop/rspec/instance_spy_spec.rb
+++ b/spec/rubocop/cop/rspec/instance_spy_spec.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::InstanceSpy do
-  subject(:cop) { described_class.new }
-
   context 'when used with `have_received`' do
     it 'adds an offense for an instance_double with single argument' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           foo = instance_double(Foo).as_null_object
                 ^^^^^^^^^^^^^^^^^^^^ Use `instance_spy` when you check your double with `have_received`.
@@ -13,7 +11,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           foo = instance_spy(Foo)
           expect(foo).to have_received(:bar)
@@ -22,7 +20,7 @@
     end
 
     it 'adds an offense for an instance_double with multiple arguments' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           foo = instance_double(Foo, :name).as_null_object
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `instance_spy` when you check your double with `have_received`.
@@ -30,7 +28,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           foo = instance_spy(Foo, :name)
           expect(foo).to have_received(:bar)
@@ -39,18 +37,28 @@
     end
 
     it 'ignores instance_double when it is not used with as_null_object' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           foo = instance_double(Foo)
           expect(bar).to have_received(:bar)
-       end
+        end
+      RUBY
+    end
+
+    it 'ignores instance_double when expect is called on another variable' do
+      expect_no_offenses(<<~RUBY)
+        it do
+          foo = instance_double(Foo).as_null_object
+          bar = instance_spy(Bar).as_null_object
+          expect(bar).to have_received(:baz)
+        end
       RUBY
     end
   end
 
   context 'when not used with `have_received`' do
-    it 'does not add an offence' do
-      expect_no_offenses(<<-RUBY)
+    it 'does not add an offense' do
+      expect_no_offenses(<<~RUBY)
         it do
           foo = instance_double(Foo).as_null_object
           expect(bar).to have_received(:bar)
diff --git a/spec/rubocop/cop/rspec/instance_variable_spec.rb b/spec/rubocop/cop/rspec/instance_variable_spec.rb
index 0e398c0d0..9e57808f2 100644
--- a/spec/rubocop/cop/rspec/instance_variable_spec.rb
+++ b/spec/rubocop/cop/rspec/instance_variable_spec.rb
@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::InstanceVariable do
-  subject(:cop) { described_class.new }
-
   it 'flags an instance variable inside a describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe MyClass do
         before { @foo = [] }
         it { expect(@foo).to be_empty }
-                    ^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                    ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
       end
     RUBY
   end
 
   it 'ignores non-spec blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       not_rspec do
         before { @foo = [] }
         it { expect(@foo).to be_empty }
@@ -23,35 +21,35 @@
   end
 
   it 'flags an instance variable inside a shared example' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       shared_examples 'shared example' do
         it { expect(@foo).to be_empty }
-                    ^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                    ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
       end
     RUBY
   end
 
   it 'flags several instance variables inside a describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe MyClass do
         before { @foo = [] }
         it { expect(@foo).to be_empty }
-                    ^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                    ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
         it { expect(@bar).to be_empty }
-                    ^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                    ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
       end
     RUBY
   end
 
   it 'ignores an instance variable without describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       @foo = []
       @foo.empty?
     RUBY
   end
 
   it 'ignores an instance variable inside a dynamic class' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe MyClass do
         let(:object) do
           Class.new(OtherClass) do
@@ -70,7 +68,7 @@ def serialize
 
   # Regression test for nevir/rubocop-rspec#115
   it 'ignores instance variables outside of specs' do
-    expect_no_offenses(<<-RUBY, 'lib/source_code.rb')
+    expect_no_offenses(<<~RUBY, 'lib/source_code.rb')
       feature do
         @foo = bar
 
@@ -108,7 +106,7 @@ def serialize
           end
 
           it { expect(color: 1).to @matcher }
-                                   ^^^^^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                                   ^^^^^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
         end
       RUBY
     end
@@ -130,29 +128,41 @@ def serialize
     end
   end
 
-  context 'when configured with AssignmentOnly', :config do
-    subject(:cop) { described_class.new(config) }
-
+  context 'when configured with AssignmentOnly' do
     let(:cop_config) do
       { 'AssignmentOnly' => true }
     end
 
     it 'flags an instance variable when it is also assigned' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass do
           before { @foo = [] }
           it { expect(@foo).to be_empty }
-                      ^^^^ Avoid instance variables – use let, a method call, or a local variable (if possible).
+                      ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
         end
       RUBY
     end
 
     it 'ignores an instance variable when it is not assigned' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe MyClass do
           it { expect(@foo).to be_empty }
         end
       RUBY
     end
+
+    it 'flags an instance variable when it is also assigned ' \
+       'in a sibling example group' do
+      expect_offense(<<~RUBY)
+        describe MyClass do
+          context 'foo' do
+            before { @foo = [] }
+          end
+
+          it { expect(@foo).to be_empty }
+                      ^^^^ Avoid instance variables - use let, a method call, or a local variable (if possible).
+        end
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/invalid_predicate_matcher_spec.rb b/spec/rubocop/cop/rspec/invalid_predicate_matcher_spec.rb
deleted file mode 100644
index 19715e16a..000000000
--- a/spec/rubocop/cop/rspec/invalid_predicate_matcher_spec.rb
+++ /dev/null
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::InvalidPredicateMatcher do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for double question' do
-    expect_offense(<<-RUBY)
-      expect(foo).to be_something?
-                     ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `not_to`' do
-    expect_offense(<<-RUBY)
-      expect(foo).not_to be_something?
-                         ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `to_not`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to_not be_something?
-                         ^^^^^^^^^^^^^ Omit `?` from `be_something?`.
-    RUBY
-  end
-
-  it 'registers an offense for double question with `have_something?`' do
-    expect_offense(<<-RUBY)
-      expect(foo).to have_something?
-                     ^^^^^^^^^^^^^^^ Omit `?` from `have_something?`.
-    RUBY
-  end
-
-  it 'accepts valid predicate matcher' do
-    expect_no_offenses(<<-RUBY)
-      expect(foo).to be_something
-    RUBY
-  end
-end
diff --git a/spec/rubocop/cop/rspec/is_expected_specify_spec.rb b/spec/rubocop/cop/rspec/is_expected_specify_spec.rb
new file mode 100644
index 000000000..b6e2dbfd3
--- /dev/null
+++ b/spec/rubocop/cop/rspec/is_expected_specify_spec.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::IsExpectedSpecify, :config do
+  it 'registers an offense when using `specify` and one-liner style' do
+    expect_offense(<<~RUBY)
+      specify { is_expected.to be_truthy }
+      ^^^^^^^ Use `it` instead of `specify`.
+      specify { are_expected.to be_falsy }
+      ^^^^^^^ Use `it` instead of `specify`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { is_expected.to be_truthy }
+      it { are_expected.to be_falsy }
+    RUBY
+  end
+
+  it 'does not register an offense when using `specify` ' \
+     'and not one-liner style' do
+    expect_no_offenses(<<~RUBY)
+      specify { expect(sqrt(4)).to eq(2) }
+    RUBY
+  end
+
+  it 'does not register an offense when using `specify` and multi line' do
+    expect_no_offenses(<<~RUBY)
+      specify do
+        is_expected.to be_truthy
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `it` and one-liner style' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to be_truthy }
+    RUBY
+  end
+
+  it 'does not register an offense when using `specify` with metadata' do
+    expect_no_offenses(<<~RUBY)
+      specify "pending", :pending
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/it_behaves_like_spec.rb b/spec/rubocop/cop/rspec/it_behaves_like_spec.rb
index 6ef27ba2d..94a216ccd 100644
--- a/spec/rubocop/cop/rspec/it_behaves_like_spec.rb
+++ b/spec/rubocop/cop/rspec/it_behaves_like_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ItBehavesLike, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ItBehavesLike do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
@@ -10,18 +8,18 @@
   context 'when the enforced style is `it_behaves_like`' do
     let(:enforced_style) { :it_behaves_like }
 
-    it 'flags a violation for it_should_behave_like' do
-      expect_offense(<<-RUBY)
+    it 'flags an offense for it_should_behave_like' do
+      expect_offense(<<~RUBY)
         it_should_behave_like 'a foo'
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `it_behaves_like` over `it_should_behave_like` when including examples in a nested context.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it_behaves_like 'a foo'
       RUBY
     end
 
-    it 'does not flag a violation for it_behaves_like' do
+    it 'does not flag an offense for it_behaves_like' do
       expect_no_offenses("it_behaves_like 'a foo'")
     end
   end
@@ -29,18 +27,18 @@
   context 'when the enforced style is `it_should_behave_like`' do
     let(:enforced_style) { :it_should_behave_like }
 
-    it 'flags a violation for it_behaves_like' do
-      expect_offense(<<-RUBY)
+    it 'flags an offense for it_behaves_like' do
+      expect_offense(<<~RUBY)
         it_behaves_like 'a foo'
         ^^^^^^^^^^^^^^^^^^^^^^^ Prefer `it_should_behave_like` over `it_behaves_like` when including examples in a nested context.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it_should_behave_like 'a foo'
       RUBY
     end
 
-    it 'does not flag a violation for it_behaves_like' do
+    it 'does not flag an offense for it_behaves_like' do
       expect_no_offenses("it_should_behave_like 'a foo'")
     end
   end
diff --git a/spec/rubocop/cop/rspec/iterated_expectation_spec.rb b/spec/rubocop/cop/rspec/iterated_expectation_spec.rb
index b894c5235..81b379071 100644
--- a/spec/rubocop/cop/rspec/iterated_expectation_spec.rb
+++ b/spec/rubocop/cop/rspec/iterated_expectation_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::IteratedExpectation do
-  subject(:cop) { described_class.new }
-
   it 'flags `each` with an expectation' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each { |user| expect(user).to be_valid }
         ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
@@ -13,7 +11,7 @@
   end
 
   it 'flags `each` when expectation calls method with arguments' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each { |user| expect(user).to be_a(User) }
         ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
@@ -22,15 +20,23 @@
   end
 
   it 'ignores `each` without expectation' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each { |user| allow(user).to receive(:method) }
       end
     RUBY
   end
 
+  it 'ignores `each` with unused variable' do
+    expect_no_offenses(<<~RUBY)
+      it 'validates users' do
+        [user1, user2, user3].each { |_user| do_something }
+      end
+    RUBY
+  end
+
   it 'flags `each` with multiple expectations' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each do |user|
         ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
@@ -42,7 +48,7 @@
   end
 
   it 'ignore `each` when the body does not contain only expectations' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each do |user|
           allow(Something).to receive(:method).and_return(user)
@@ -54,7 +60,7 @@
   end
 
   it 'ignores `each` with expectation on property' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each { |user| expect(user.name).to be }
       end
@@ -62,7 +68,7 @@
   end
 
   it 'ignores assignments in the iteration' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each { |user| array = array.concat(user) }
       end
@@ -70,7 +76,7 @@
   end
 
   it 'ignores `each` when there is a negative expectation' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'validates users' do
         [user1, user2, user3].each do |user|
           expect(user).not_to receive(:method)
@@ -79,4 +85,83 @@
       end
     RUBY
   end
+
+  context 'when Ruby 2.7', :ruby27 do
+    it 'flags `each` with an expectation' do
+      expect_offense(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each { expect(_1).to be_valid }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
+        end
+      RUBY
+    end
+
+    it 'flags `each` when expectation calls method with arguments' do
+      expect_offense(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each { expect(_1).to be_a(User) }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
+        end
+      RUBY
+    end
+
+    it 'ignores `each` without expectation' do
+      expect_no_offenses(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each { allow(_1).to receive(:method) }
+        end
+      RUBY
+    end
+
+    it 'flags `each` with multiple expectations' do
+      expect_offense(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using the `all` matcher instead of iterating over an array.
+            expect(_1).to receive(:method)
+            expect(_1).to receive(:other_method)
+          end
+        end
+      RUBY
+    end
+
+    it 'ignore `each` when the body does not contain only expectations' do
+      expect_no_offenses(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each do
+            allow(Something).to receive(:method).and_return(_1)
+            expect(_1).to receive(:method)
+            expect(_1).to receive(:other_method)
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores `each` with expectation on property' do
+      expect_no_offenses(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each { expect(_1.name).to be }
+        end
+      RUBY
+    end
+
+    it 'ignores assignments in the iteration' do
+      expect_no_offenses(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each { array = array.concat(_1) }
+        end
+      RUBY
+    end
+
+    it 'ignores `each` when there is a negative expectation' do
+      expect_no_offenses(<<~RUBY)
+        it 'validates users' do
+          [user1, user2, user3].each do
+            expect(_1).not_to receive(:method)
+            expect(_1).to receive(:other_method)
+          end
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/leading_subject_spec.rb b/spec/rubocop/cop/rspec/leading_subject_spec.rb
index 20c6fe72a..70558d92a 100644
--- a/spec/rubocop/cop/rspec/leading_subject_spec.rb
+++ b/spec/rubocop/cop/rspec/leading_subject_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::LeadingSubject do
-  subject(:cop) { described_class.new }
-
-  it 'checks subject below let' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for subject below let' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:params) { foo }
 
@@ -13,7 +11,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
         let(:params) { foo }
@@ -22,8 +20,8 @@
     RUBY
   end
 
-  it 'checks subject below let!' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for subject below let!' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let!(:params) { foo }
 
@@ -32,7 +30,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
         let!(:params) { foo }
@@ -41,21 +39,40 @@
     RUBY
   end
 
-  it 'approves of subject above let' do
-    expect_no_offenses(<<-RUBY)
+  it 'registers an offense for subject below let with proc argument' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
-        context 'blah' do
-        end
+        let(:user, &args[:build_user])
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `let` declarations.
+      end
+    RUBY
 
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+        let(:user, &args[:build_user])
+
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for subject above let' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe User do
         subject { described_class.new }
 
         let(:params) { foo }
+
+        context 'blah' do
+        end
       end
     RUBY
   end
 
-  it 'handles subjects in contexts' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for subjects in contexts' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:params) { foo }
 
@@ -66,8 +83,8 @@
     RUBY
   end
 
-  it 'handles subjects in tests' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for subjects in tests' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         # This shouldn't really ever happen in a sane codebase but I still
         # want to avoid false positives
@@ -79,8 +96,8 @@
     RUBY
   end
 
-  it 'checks subject below hook' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for subject below hook' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         before { allow(Foo).to receive(:bar) }
 
@@ -89,7 +106,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
         before { allow(Foo).to receive(:bar) }
@@ -98,8 +115,8 @@
     RUBY
   end
 
-  it 'checks subject below example' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for subject below example' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         it { is_expected.to be_present }
 
@@ -108,7 +125,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         subject { described_class.new }
         it { is_expected.to be_present }
@@ -116,4 +133,160 @@
       end
     RUBY
   end
+
+  it 'registers an offense when subject is below a non-offending node' do
+    expect_offense(<<~RUBY)
+      RSpec.describe do
+        def helper_method
+        end
+
+        it { is_expected.to be_present }
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `it` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe do
+        def helper_method
+        end
+
+        subject { described_class.new }
+        it { is_expected.to be_present }
+
+      end
+    RUBY
+  end
+
+  it 'registers an offense for subject below example group' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        describe do
+          it { is_expected.to be_present }
+        end
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `describe` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+        describe do
+          it { is_expected.to be_present }
+        end
+
+      end
+    RUBY
+  end
+
+  it 'registers an offense for subject below shared example group' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        shared_examples_for 'used later' do
+          it { is_expected.to be_present }
+        end
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `shared_examples_for` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+        shared_examples_for 'used later' do
+          it { is_expected.to be_present }
+        end
+
+      end
+    RUBY
+  end
+
+  it 'registers an offense for subject below include' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it_behaves_like 'a good citizen'
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `it_behaves_like` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+        it_behaves_like 'a good citizen'
+
+      end
+    RUBY
+  end
+
+  it 'registers an offense for subject below include with a block' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it_behaves_like 'a good citizen' do
+          let(:used_in_shared_examples) { 'something' }
+        end
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `it_behaves_like` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+        it_behaves_like 'a good citizen' do
+          let(:used_in_shared_examples) { 'something' }
+        end
+
+      end
+    RUBY
+  end
+
+  it 'registers an offense for subject below include with a blockpass' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        block = ->{ }
+        it_behaves_like 'a good citizen', &block
+
+        subject { described_class.new }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Declare `subject` above any other `it_behaves_like` declarations.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        block = ->{ }
+        subject { described_class.new }
+        it_behaves_like 'a good citizen', &block
+
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for subject nested inside a block' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe User do
+        let(:foo) { 'bar' }
+
+        it_behaves_like 'a good citizen' do
+          subject { described_class.new }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for subject in arbitrary code' do
+    expect_no_offenses(<<~RUBY)
+      module Support
+        subject do
+          test
+        end
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/leaky_constant_declaration_spec.rb b/spec/rubocop/cop/rspec/leaky_constant_declaration_spec.rb
index bec0dedc3..0a1164efb 100644
--- a/spec/rubocop/cop/rspec/leaky_constant_declaration_spec.rb
+++ b/spec/rubocop/cop/rspec/leaky_constant_declaration_spec.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::LeakyConstantDeclaration do
-  subject(:cop) { described_class.new }
-
   describe 'constant assignment' do
     it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe SomeClass do
           CONSTANT = "Accessible as ::CONSTANT".freeze
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub constant instead of declaring explicitly.
@@ -14,7 +12,7 @@
     end
 
     it 'flags inside shared example group' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.shared_examples 'shared example' do
           CONSTANT = "Accessible as ::CONSTANT".freeze
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub constant instead of declaring explicitly.
@@ -23,7 +21,7 @@
     end
 
     it 'flags inside an example' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe SomeClass do
           specify do
             CONSTANT = "Accessible as ::CONSTANT".freeze
@@ -33,8 +31,32 @@
       RUBY
     end
 
+    it 'ignores constant defined on the example group' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          self::CONSTANT = "Accessible as self.class::CONSTANT".freeze
+        end
+      RUBY
+    end
+
+    it 'ignores constant defined in an explicit namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          Foo::CONSTANT = "Accessible as Foo::CONSTANT".freeze
+        end
+      RUBY
+    end
+
+    it 'ignores classes defined explicitly in the global namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          ::CONSTANT = "Accessible as ::CONSTANT".freeze
+        end
+      RUBY
+    end
+
     it 'ignores outside of example/shared group' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         factory :some_class do
           CONSTANT = "Accessible as ::CONSTANT".freeze
         end
@@ -44,7 +66,7 @@
 
   describe 'class defined' do
     it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe SomeClass do
           class DummyClass < described_class
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub class constant instead of declaring explicitly.
@@ -54,7 +76,7 @@ class DummyClass < described_class
     end
 
     it 'ignores anonymous classes' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe SomeClass do
           let(:dummy_playbook) do
             Class.new do
@@ -62,24 +84,48 @@ def method
               end
             end
           end
-         end
+        end
+      RUBY
+    end
+
+    it 'ignores classes defined on the example group' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          class self::DummyClass
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores classes defined in an explicit namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          class Foo::DummyClass
+          end
+        end
       RUBY
     end
 
-    it 'flags namespaced class' do
-      expect_offense(<<-RUBY)
+    it 'ignores classes defined explicitly in the global namespace' do
+      expect_no_offenses(<<~RUBY)
         describe SomeClass do
-          class SomeModule::AnotherModule::DummyClass
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Stub class constant instead of declaring explicitly.
+          class ::DummyClass
           end
         end
       RUBY
     end
+
+    it 'ignores outside of example/shared group' do
+      expect_no_offenses(<<~RUBY)
+        class DummyClass
+        end
+      RUBY
+    end
   end
 
   describe 'module defined' do
     it 'flags inside an example group' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe SomeClass do
           module DummyModule
           ^^^^^^^^^^^^^^^^^^ Stub module constant instead of declaring explicitly.
@@ -87,5 +133,39 @@ module DummyModule
         end
       RUBY
     end
+
+    it 'ignores modules defined on the example group' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          module self::DummyModule
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores modules defined in an explicit namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          module Foo::DummyModule
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores modules defined explicitly in the global namespace' do
+      expect_no_offenses(<<~RUBY)
+        describe SomeClass do
+          module ::DummyModule
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores outside of example/shared group' do
+      expect_no_offenses(<<~RUBY)
+        module Dummymodule
+        end
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/let_before_examples_spec.rb b/spec/rubocop/cop/rspec/let_before_examples_spec.rb
index a2a1077b0..d0a3d75ab 100644
--- a/spec/rubocop/cop/rspec/let_before_examples_spec.rb
+++ b/spec/rubocop/cop/rspec/let_before_examples_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::LetBeforeExamples do
-  subject(:cop) { described_class.new }
-
   it 'flags `let` after `it`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         it { is_expected.to be_after_let }
         let(:foo) { bar }
@@ -12,7 +10,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:foo) { bar }
         it { is_expected.to be_after_let }
@@ -21,7 +19,7 @@
   end
 
   it 'flags `let` after `context`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         context 'a context' do
           it { is_expected.to be_after_let }
@@ -32,7 +30,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:foo) { bar }
         context 'a context' do
@@ -43,27 +41,85 @@
     RUBY
   end
 
-  it 'flags `let` after `include_examples`' do
-    expect_offense(<<-RUBY)
+  it 'flags `let` after `include_examples`, but does not autocorrect' do
+    # NOTE: include_examples may define the same variable as `let`,
+    # and changing the order may break the spec due to order dependency
+    # if `let` is moved above.
+    expect_offense(<<~RUBY)
       RSpec.describe User do
-        include_examples('should be after let')
+        include_examples('should be BEFORE let as it defines `let(:foo)`, too')
+
+        let(:foo) { 'bar' }
+        ^^^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
+      end
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'flags `let` after `it_behaves_like`' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it_behaves_like('should be after let')
 
         let(:foo) { bar }
         ^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:foo) { bar }
-        include_examples('should be after let')
+        it_behaves_like('should be after let')
+
+      end
+    RUBY
+  end
+
+  it 'flags `let` with proc argument' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it_behaves_like('should be after let')
+
+        let(:user, &args[:build_user])
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        let(:user, &args[:build_user])
+        it_behaves_like('should be after let')
+
+      end
+    RUBY
+  end
+
+  it 'flags `let` with a heredoc argument' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        it_behaves_like('should be after let')
+
+        let(:foo) { (<<-SOURCE) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^ Move `let` before the examples in the group.
+        some long text here
+        SOURCE
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        let(:foo) { (<<-SOURCE) }
+        some long text here
+        SOURCE
+        it_behaves_like('should be after let')
 
       end
     RUBY
   end
 
   it 'does not flag `let` before the examples' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:foo) { bar }
 
@@ -73,13 +129,13 @@
           it { is_expected.to work }
         end
 
-        include_examples('everything is fine')
+        it_behaves_like('everything is fine')
       end
     RUBY
   end
 
   it 'does not flag `let` in a nested context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:foo) { bar }
 
@@ -88,13 +144,13 @@
           it { is_expected.to work }
         end
 
-        include_examples('everything is fine')
+        it_behaves_like('everything is fine')
       end
     RUBY
   end
 
   it 'allows inclusion of context before `let`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         include_context 'special user'
 
@@ -104,34 +160,12 @@
   end
 
   it 'ignores single-line example blocks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
-        include_examples 'special user' do
+        it_behaves_like 'special user' do
           let(:foo) { bar }
         end
       end
     RUBY
   end
-
-  bad_code = <<-RUBY
-    RSpec.describe User do
-      include_examples('should be after let')
-
-      let(:foo) { (<<-SOURCE) }
-      some long text here
-      SOURCE
-    end
-  RUBY
-
-  good_code = <<-RUBY
-    RSpec.describe User do
-      let(:foo) { (<<-SOURCE) }
-      some long text here
-      SOURCE
-      include_examples('should be after let')
-
-    end
-  RUBY
-
-  include_examples 'autocorrect', bad_code, good_code
 end
diff --git a/spec/rubocop/cop/rspec/let_setup_spec.rb b/spec/rubocop/cop/rspec/let_setup_spec.rb
index 7d42305cc..0e75106bd 100644
--- a/spec/rubocop/cop/rspec/let_setup_spec.rb
+++ b/spec/rubocop/cop/rspec/let_setup_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::LetSetup do
-  subject(:cop) { described_class.new }
-
   it 'complains when let! is used and not referenced' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         let!(:foo) { bar }
         ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
@@ -17,7 +15,7 @@
   end
 
   it 'ignores let! when used in `before`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         let!(:foo) { bar }
 
@@ -33,7 +31,7 @@
   end
 
   it 'ignores let! when used in example' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         let!(:foo) { bar }
 
@@ -46,7 +44,7 @@
   end
 
   it 'complains when let! is used and not referenced within nested group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         context 'when something special happens' do
           let!(:foo) { bar }
@@ -63,4 +61,80 @@
       end
     RUBY
   end
+
+  it 'complains when let! is used and not referenced in shared example group' do
+    expect_offense(<<~RUBY)
+      shared_context 'foo' do
+        let!(:bar) { baz }
+        ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+
+        it 'does not use bar' do
+          expect(baz).to eq(qux)
+        end
+      end
+    RUBY
+  end
+
+  it 'complains when let! used in shared example including' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        it_behaves_like 'bar' do
+          let!(:baz) { foobar }
+          ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+          let(:a) { b }
+        end
+      end
+    RUBY
+  end
+
+  it 'complains when there is only one nested node into example group' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        let!(:bar) { baz }
+        ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+      end
+    RUBY
+  end
+
+  it 'flags unused helpers defined as strings' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        let!('bar') { baz }
+        ^^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+      end
+    RUBY
+  end
+
+  it 'ignores used helpers defined as strings' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        let!('bar') { baz }
+        it { expect(bar).to be_near }
+      end
+    RUBY
+  end
+
+  it 'flags blockpass' do
+    expect_offense(<<~RUBY)
+      shared_context Foo do |&block|
+        let!(:bar, &block)
+        ^^^^^^^^^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+      end
+    RUBY
+  end
+
+  it 'complains when there is a custom nesting level' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        [].each do |i|
+          let!(:bar) { i }
+          ^^^^^^^^^^ Do not use `let!` to setup objects not referenced in tests.
+
+          it 'does not use bar' do
+            expect(baz).to eq(qux)
+          end
+        end
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/match_array_spec.rb b/spec/rubocop/cop/rspec/match_array_spec.rb
new file mode 100644
index 000000000..947626e30
--- /dev/null
+++ b/spec/rubocop/cop/rspec/match_array_spec.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::MatchArray do
+  it 'flags `match_array` with array literal arguments' do
+    expect_offense(<<~RUBY)
+      it { is_expected.to match_array([content1, content2]) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `contain_exactly` when matching an array literal.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { is_expected.to contain_exactly(content1, content2) }
+    RUBY
+  end
+
+  it 'flags `match_array` with array literal arguments including a splat' do
+    expect_offense(<<~RUBY)
+      it { is_expected.to match_array([*content1, content2]) }
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `contain_exactly` when matching an array literal.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it { is_expected.to contain_exactly(*content1, content2) }
+    RUBY
+  end
+
+  it 'does not flag `contain_exactly`' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to contain_exactly(content1, content2) }
+    RUBY
+  end
+
+  it 'does not flag `match_array` with mixed arguments' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to match_array([content] + array) }
+    RUBY
+  end
+
+  it 'does not flag `match_array` with a percent array' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+      it { is_expected.to match_array(%i(foo bar baz)) }
+    RUBY
+  end
+
+  # Don't do the work of RSpec/BeEmpty
+  it 'does not flag `match_array` with an empty array literal' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to match_array([]) }
+    RUBY
+  end
+
+  it 'does not flag `match_array` with no argument' do
+    expect_no_offenses(<<~RUBY)
+      it { is_expected.to match_array }
+      it { is_expected.to match_array() }
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/message_chain_spec.rb b/spec/rubocop/cop/rspec/message_chain_spec.rb
index 7ede24e58..980d4cb5b 100644
--- a/spec/rubocop/cop/rspec/message_chain_spec.rb
+++ b/spec/rubocop/cop/rspec/message_chain_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::MessageChain do
-  subject(:cop) { described_class.new }
-
   it 'finds `receive_message_chain`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         allow(foo).to receive_message_chain(:one, :two) { :three }
                       ^^^^^^^^^^^^^^^^^^^^^ Avoid stubbing using `receive_message_chain`.
@@ -13,7 +11,7 @@
   end
 
   it 'finds old `stub_chain` syntax' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       before do
         foo.stub_chain(:one, :two).and_return(:three)
             ^^^^^^^^^^ Avoid stubbing using `stub_chain`.
diff --git a/spec/rubocop/cop/rspec/message_expectation_spec.rb b/spec/rubocop/cop/rspec/message_expectation_spec.rb
index 3d7a63dfc..3693244e8 100644
--- a/spec/rubocop/cop/rspec/message_expectation_spec.rb
+++ b/spec/rubocop/cop/rspec/message_expectation_spec.rb
@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::MessageExpectation, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::MessageExpectation do
   context 'when EnforcedStyle is allow' do
     let(:cop_config) do
       { 'EnforcedStyle' => 'allow' }
     end
 
     it 'flags expect(...).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to receive(:bar)
         ^^^^^^ Prefer `allow` for setting message expectations.
       RUBY
@@ -19,8 +17,8 @@
       expect_no_offenses('allow(foo).to receive(:bar)')
     end
 
-    include_examples 'detects style', 'allow(foo).to receive(:bar)',  'allow'
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'expect'
+    it_behaves_like 'detects style', 'allow(foo).to receive(:bar)',  'allow'
+    it_behaves_like 'detects style', 'expect(foo).to receive(:bar)', 'expect'
   end
 
   context 'when EnforcedStyle is expect' do
@@ -29,7 +27,7 @@
     end
 
     it 'flags allow(...).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         allow(foo).to receive(:bar)
         ^^^^^ Prefer `expect` for setting message expectations.
       RUBY
@@ -39,7 +37,7 @@
       expect_no_offenses('expect(foo).to receive(:bar)')
     end
 
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'expect'
-    include_examples 'detects style', 'allow(foo).to receive(:bar)',  'allow'
+    it_behaves_like 'detects style', 'expect(foo).to receive(:bar)', 'expect'
+    it_behaves_like 'detects style', 'allow(foo).to receive(:bar)',  'allow'
   end
 end
diff --git a/spec/rubocop/cop/rspec/message_spies_spec.rb b/spec/rubocop/cop/rspec/message_spies_spec.rb
index fe6bce12f..66baf7cd1 100644
--- a/spec/rubocop/cop/rspec/message_spies_spec.rb
+++ b/spec/rubocop/cop/rspec/message_spies_spec.rb
@@ -1,22 +1,20 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::MessageSpies, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::MessageSpies do
   context 'when EnforcedStyle is have_received' do
     let(:cop_config) do
       { 'EnforcedStyle' => 'have_received' }
     end
 
     it 'flags expect(send).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to receive(:bar)
                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(lvar).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         foo = baz
         expect(foo).to receive(:bar)
                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
@@ -24,42 +22,42 @@
     end
 
     it 'flags expect(ivar).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(@foo).to receive(:bar)
                         ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `@foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(const).to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(Foo).to receive(:bar)
                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `Foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(...).not_to receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).not_to receive(:bar)
                            ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(...).to_not receive' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to_not receive(:bar)
                            ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(...).to receive with' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to receive(:bar).with(:baz)
                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
       RUBY
     end
 
     it 'flags expect(...).to receive at_most' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to receive(:bar).at_most(42).times
                        ^^^^^^^ Prefer `have_received` for setting message expectations. Setup `foo` as a spy using `allow` or `instance_spy`.
       RUBY
@@ -69,11 +67,11 @@
       expect_no_offenses('expect(foo).to have_received(:bar)')
     end
 
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'receive'
+    it_behaves_like 'detects style', 'expect(foo).to receive(:bar)', 'receive'
 
-    include_examples 'detects style',
-                     'expect(foo).to have_received(:bar)',
-                     'have_received'
+    it_behaves_like 'detects style',
+                    'expect(foo).to have_received(:bar)',
+                    'have_received'
   end
 
   context 'when EnforcedStyle is receive' do
@@ -82,14 +80,14 @@
     end
 
     it 'flags expect(send).to have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to have_received(:bar)
                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(lvar).to have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         foo = baz
         expect(foo).to have_received(:bar)
                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
@@ -97,42 +95,42 @@
     end
 
     it 'flags expect(ivar).to have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(@foo).to have_received(:bar)
                         ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(const).to have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(Foo).to have_received(:bar)
                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(...).not_to have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).not_to have_received(:bar)
                            ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(...).to_not have_received' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to_not have_received(:bar)
                            ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(...).to have_received with' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to have_received(:bar).with(:baz)
                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
     end
 
     it 'flags expect(...).to have_received at_most' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect(foo).to have_received(:bar).at_most(42).times
                        ^^^^^^^^^^^^^ Prefer `receive` for setting message expectations.
       RUBY
@@ -142,10 +140,10 @@
       expect_no_offenses('expect(foo).to receive(:bar)')
     end
 
-    include_examples 'detects style', 'expect(foo).to receive(:bar)', 'receive'
+    it_behaves_like 'detects style', 'expect(foo).to receive(:bar)', 'receive'
 
-    include_examples 'detects style',
-                     'expect(foo).to have_received(:bar)',
-                     'have_received'
+    it_behaves_like 'detects style',
+                    'expect(foo).to have_received(:bar)',
+                    'have_received'
   end
 end
diff --git a/spec/rubocop/cop/rspec/metadata_style_spec.rb b/spec/rubocop/cop/rspec/metadata_style_spec.rb
new file mode 100644
index 000000000..810e3816a
--- /dev/null
+++ b/spec/rubocop/cop/rspec/metadata_style_spec.rb
@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::MetadataStyle do
+  context 'with `EnforcedStyle: symbol`' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'symbol' }
+    end
+
+    context 'with symbol metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', :a do
+          end
+        RUBY
+      end
+    end
+
+    context 'with false metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', a: false do
+          end
+        RUBY
+      end
+    end
+
+    context 'with string key metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', 'a' => true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 1 boolean keyword arguments metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', a: true do
+                                ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 2 boolean keyword arguments metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', a: true, b: true do
+                                         ^^^^^^^ Use symbol style for metadata.
+                                ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, :b do
+          end
+        RUBY
+      end
+    end
+
+    context 'with non-boolean and boolean keyword arguments metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', b: 1, a: true do
+                                      ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, b: 1 do
+          end
+        RUBY
+      end
+    end
+
+    context 'with boolean and non-boolean keyword arguments metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', a: true, b: 1 do
+                                ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, b: 1 do
+          end
+        RUBY
+      end
+    end
+
+    context 'with non-literal metadata and symbol metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', a, :b do
+          end
+        RUBY
+      end
+    end
+
+    context 'with boolean keyword arguments metadata and symbol metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :b, a: true do
+                                    ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :b, :a do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 1 boolean hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', { a: true } do
+                                  ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, {  } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 2 boolean hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', { a: true, b: true } do
+                                           ^^^^^^^ Use symbol style for metadata.
+                                  ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, :b, {  } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with boolean and non-boolean hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', { a: true, b: 1 } do
+                                  ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, { b: 1 } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with non-boolean and boolean hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', { b: 1, a: true } do
+                                        ^^^^^^^ Use symbol style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', :a, { b: 1 } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with non-symbol-key hash metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', a => true do
+          end
+        RUBY
+      end
+    end
+  end
+
+  context 'with `EnforcedStyle: hash`' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'hash' }
+    end
+
+    context 'with boolean keyword arguments metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', a: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with boolean hash metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', { a: true } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with boolean hash metadata after 2 string arguments' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', 'Something else', { a: true } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 1 symbol metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', a: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 2 symbol metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a, :b do
+                                    ^^ Use hash style for metadata.
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', b: true, a: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with 2 non-literal metadata' do
+      it 'registers no offense' do
+        expect_no_offenses(<<~RUBY)
+          describe 'Something', a, b do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata after 2 string arguments' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', 'Something else', :a do
+                                                  ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', 'Something else', a: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata after non-literal metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', a, :b do
+                                   ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', a, b: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata with parentheses' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe('Something', :a) do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe('Something', a: true) do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata with another existing hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a, b: 1 do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', b: 1, a: true do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata with another existing braces hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a, { b: 1 } do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', { b: 1, a: true } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata with another existing empty hash metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a, {} do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          describe 'Something', { a: true } do
+          end
+        RUBY
+      end
+    end
+
+    context 'with symbol metadata with another existing non-literal metadata' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          describe 'Something', :a, b do
+                                ^^ Use hash style for metadata.
+          end
+        RUBY
+
+        expect_no_corrections
+      end
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/missing_example_group_argument_spec.rb b/spec/rubocop/cop/rspec/missing_example_group_argument_spec.rb
index e01e4c8b1..0498ed8b3 100644
--- a/spec/rubocop/cop/rspec/missing_example_group_argument_spec.rb
+++ b/spec/rubocop/cop/rspec/missing_example_group_argument_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::MissingExampleGroupArgument do
-  subject(:cop) { described_class.new }
-
   it 'accepts describe with an argument' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe FooClass do
       end
 
@@ -14,7 +12,7 @@
   end
 
   it 'accepts methods with a name like an example block' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       Scenario.context do
         'static'
       end
@@ -22,7 +20,7 @@
   end
 
   it 'checks first argument of describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe do
       ^^^^^^^^^^^ The first argument to `describe` should not be empty.
       end
@@ -34,7 +32,7 @@
   end
 
   it 'checks first argument of nested describe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe FooClass do
         describe do
         ^^^^^^^^^^^ The first argument to `describe` should not be empty.
@@ -48,7 +46,7 @@
   end
 
   it 'checks first argument of context' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context do
       ^^^^^^^^^^ The first argument to `context` should not be empty.
       end
diff --git a/spec/rubocop/cop/rspec/missing_expectation_target_method_spec.rb b/spec/rubocop/cop/rspec/missing_expectation_target_method_spec.rb
new file mode 100644
index 000000000..806adc671
--- /dev/null
+++ b/spec/rubocop/cop/rspec/missing_expectation_target_method_spec.rb
@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::MissingExpectationTargetMethod do
+  it 'registers offenses to other than `to` or `not_to`' do
+    expect_offense(<<~RUBY)
+      it 'something' do
+        something = 1
+        expect(something).kind_of? Integer
+                          ^^^^^^^^ Use `.to`, `.not_to` or `.to_not` to set an expectation.
+      end
+    RUBY
+  end
+
+  it 'registers offenses to other than `to` or `not_to` ' \
+     'when block has one expression' do
+    expect_offense(<<~RUBY)
+      it 'something' do
+        expect(something).eq? 42
+                          ^^^ Use `.to`, `.not_to` or `.to_not` to set an expectation.
+      end
+    RUBY
+  end
+
+  it 'registers offenses to other than `to` or `not_to` with `is_expected`' do
+    expect_offense(<<~RUBY)
+      it 'something' do
+        is_expected == 42
+                    ^^ Use `.to`, `.not_to` or `.to_not` to set an expectation.
+      end
+    RUBY
+  end
+
+  it 'registers offenses to other than `to` or `not_to` with block' do
+    expect_offense(<<~RUBY)
+      it 'something' do
+        expect{something}.kind_of? StandardError
+                          ^^^^^^^^ Use `.to`, `.not_to` or `.to_not` to set an expectation.
+      end
+    RUBY
+  end
+
+  it 'accepts void `expect`' do
+    expect_no_offenses(<<~RUBY)
+      it 'something' do
+        expect(something)
+      end
+    RUBY
+  end
+
+  it 'accepts only `expect`' do
+    expect_no_offenses(<<~RUBY)
+      expect
+    RUBY
+  end
+
+  %w[to not_to to_not].each do |method|
+    it "accepts `.#{method}`" do
+      expect_no_offenses(<<~RUBY)
+        it 'something' do
+          expect(something).#{method} be_a Integer
+        end
+      RUBY
+    end
+
+    it "accepts `.#{method}` with `is_expected`" do
+      expect_no_offenses(<<~RUBY)
+        it 'something' do
+          is_expected.#{method} eq 42
+        end
+      RUBY
+    end
+
+    it "accepts `.#{method}` with block" do
+      expect_no_offenses(<<~RUBY)
+        it 'something' do
+          expect{something}.#{method} raise_error(StandardError)
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/mixin/location_help_spec.rb b/spec/rubocop/cop/rspec/mixin/location_help_spec.rb
new file mode 100644
index 000000000..851b90081
--- /dev/null
+++ b/spec/rubocop/cop/rspec/mixin/location_help_spec.rb
@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::LocationHelp do
+  describe 'LocationHelp.arguments_with_whitespace' do
+    subject(:arguments_with_whitespace) do
+      described_class.arguments_with_whitespace(source_ast)
+    end
+
+    let(:source_ast) { parse_source(source).ast }
+
+    context 'when `a b`' do
+      let(:source) { 'a b' }
+
+      it 'returns #<Parser::Source::Range (string) 1...3>' do
+        expect(arguments_with_whitespace.begin_pos).to eq 1
+        expect(arguments_with_whitespace.end_pos).to eq 3
+      end
+    end
+
+    context 'when `foo 1, 2`' do
+      let(:source) { 'foo 1, 2' }
+
+      it 'returns #<Parser::Source::Range (string) 3...8>' do
+        expect(arguments_with_whitespace.begin_pos).to eq 3
+        expect(arguments_with_whitespace.end_pos).to eq 8
+      end
+    end
+
+    context 'when `foo(bar, baz)`' do
+      let(:source) { 'foo(bar, baz)' }
+
+      it 'returns #<Parser::Source::Range (string) 3...13>' do
+        expect(arguments_with_whitespace.begin_pos).to eq 3
+        expect(arguments_with_whitespace.end_pos).to eq 13
+      end
+    end
+  end
+
+  describe 'LocationHelp.block_with_whitespace' do
+    subject(:block_with_whitespace) do
+      described_class.block_with_whitespace(source_ast)
+    end
+
+    context 'when `a b`' do
+      let(:source_ast) { parse_source(source).ast }
+      let(:source) { 'a b' }
+
+      it 'returns nil' do
+        expect(block_with_whitespace).to be_nil
+      end
+    end
+
+    context 'when `a.b`' do
+      let(:source_ast) { parse_source(source).ast.children.first }
+      let(:source) { 'a.b' }
+
+      it 'returns nil' do
+        expect(block_with_whitespace).to be_nil
+      end
+    end
+
+    context 'when `a { b }`' do
+      let(:source_ast) { parse_source(source).ast.children.first }
+      let(:source) { 'a { b }' }
+
+      it 'returns #<Parser::Source::Range (string) 1...7>' do
+        expect(block_with_whitespace.begin_pos).to eq 1
+        expect(block_with_whitespace.end_pos).to eq 7
+      end
+    end
+
+    context 'when `foo { bar + baz }`' do
+      let(:source_ast) { parse_source(source).ast.children.first }
+      let(:source) { 'foo { bar + baz }' }
+
+      it 'returns #<Parser::Source::Range (string) 3...17>' do
+        expect(block_with_whitespace.begin_pos).to eq 3
+        expect(block_with_whitespace.end_pos).to eq 17
+      end
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/mixin/metadata_spec.rb b/spec/rubocop/cop/rspec/mixin/metadata_spec.rb
new file mode 100644
index 000000000..df51b1c80
--- /dev/null
+++ b/spec/rubocop/cop/rspec/mixin/metadata_spec.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::Metadata do
+  describe '#on_metadata' do
+    subject(:on_metadata) do
+      stub_class.new.on_metadata(:symbol, {})
+    end
+
+    let(:stub_class) do
+      Class.new do
+        include RuboCop::Cop::RSpec::Metadata
+      end
+    end
+
+    it { expect { on_metadata }.to raise_error(NotImplementedError) }
+  end
+end
diff --git a/spec/rubocop/cop/rspec/mixin/skip_or_pending_spec.rb b/spec/rubocop/cop/rspec/mixin/skip_or_pending_spec.rb
new file mode 100644
index 000000000..ae760aa3a
--- /dev/null
+++ b/spec/rubocop/cop/rspec/mixin/skip_or_pending_spec.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SkipOrPending do
+  describe '#skipped_in_metadata?' do
+    subject(:skipped_in_metadata?) do
+      stub_class.new.send(:skipped_in_metadata?, ast)
+    end
+
+    let(:stub_class) do
+      Class.new do
+        include RuboCop::Cop::RSpec::SkipOrPending
+      end
+    end
+    let(:ast) { parse_source(source).ast.children.first }
+
+    context 'when given node contains skip' do
+      let(:source) { <<~RUBY }
+        it 'is skipped', :skip do
+          foo
+        end
+      RUBY
+
+      it 'returns true' do
+        expect(skipped_in_metadata?).to be_truthy
+      end
+    end
+
+    context 'when given node contains pending' do
+      let(:source) { <<~RUBY }
+        it 'is pending', :pending do
+          foo
+        end
+      RUBY
+
+      it 'returns true' do
+        expect(skipped_in_metadata?).to be_truthy
+      end
+    end
+
+    context 'when given node does not contain skip/pending' do
+      let(:source) { 'it("example") { }' }
+
+      it 'returns false' do
+        expect(skipped_in_metadata?).to be_falsey
+      end
+    end
+  end
+
+  describe '#skip_or_pending_inside_block?' do
+    subject(:skip_or_pending_inside_block?) do
+      stub_class.new.send(:skip_or_pending_inside_block?, ast)
+    end
+
+    let(:stub_class) do
+      Class.new do
+        include RuboCop::Cop::RSpec::SkipOrPending
+      end
+    end
+    let(:ast) { parse_source(source).ast }
+
+    context 'when given node contains skip inside block' do
+      let(:source) do
+        <<~RUBY
+          context 'when color is blue' do
+            skip 'not implemented yet'
+          end
+        RUBY
+      end
+
+      it 'returns true' do
+        expect(skip_or_pending_inside_block?).to be_truthy
+      end
+    end
+
+    context 'when given node contains pending inside block' do
+      let(:source) do
+        <<~RUBY
+          context 'when color is blue' do
+            pending 'not implemented yet'
+          end
+        RUBY
+      end
+
+      it 'returns true' do
+        expect(skip_or_pending_inside_block?).to be_truthy
+      end
+    end
+
+    context 'when given node does not contain skip inside block' do
+      let(:source) { "skip 'not implemented yet'" }
+
+      it 'returns false' do
+        expect(skip_or_pending_inside_block?).to be_falsey
+      end
+    end
+
+    context 'when given node does not contain pending inside block' do
+      let(:source) { "pending 'not implemented yet'" }
+
+      it 'returns false' do
+        expect(skip_or_pending_inside_block?).to be_falsey
+      end
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/mixin/top_level_group_spec.rb b/spec/rubocop/cop/rspec/mixin/top_level_group_spec.rb
new file mode 100644
index 000000000..251e3d711
--- /dev/null
+++ b/spec/rubocop/cop/rspec/mixin/top_level_group_spec.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::TopLevelGroup do
+  describe '#top_level_group?' do
+    let(:stub_class) do
+      Class.new do
+        include RuboCop::Cop::RSpec::TopLevelGroup
+
+        def initialize
+          @top_level_groups = []
+        end
+
+        def test_top_level_group
+          top_level_group?(nil)
+        end
+      end
+    end
+
+    it 'warns because it is deprecated' do
+      expect { stub_class.new.test_top_level_group }.to \
+        output(/warning: top_level_group\? is deprecated/).to_stderr
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/multiple_describes_spec.rb b/spec/rubocop/cop/rspec/multiple_describes_spec.rb
index 68376e697..f565adad5 100644
--- a/spec/rubocop/cop/rspec/multiple_describes_spec.rb
+++ b/spec/rubocop/cop/rspec/multiple_describes_spec.rb
@@ -1,28 +1,51 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::MultipleDescribes do
-  subject(:cop) { described_class.new }
-
-  it 'finds multiple top level describes with class and method' do
-    expect_offense(<<-RUBY)
+  it 'flags multiple top-level example groups with class and method' do
+    expect_offense(<<~RUBY)
       describe MyClass, '.do_something' do; end
-      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use multiple top-level example groups - try to nest them.
       describe MyClass, '.do_something_else' do; end
     RUBY
   end
 
-  it 'finds multiple top level describes only with class' do
-    expect_offense(<<-RUBY)
+  it 'flags multiple top-level example groups only with class' do
+    expect_offense(<<~RUBY)
       describe MyClass do; end
-      ^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
+      ^^^^^^^^^^^^^^^^ Do not use multiple top-level example groups - try to nest them.
       describe MyOtherClass do; end
     RUBY
   end
 
-  it 'skips single top level describe' do
-    expect_no_offenses(<<-RUBY)
-      require 'spec_helper'
+  it 'flags multiple top-level example groups with an arbitrary argument' do
+    expect_offense(<<~RUBY)
+      describe 'MyClass' do; end
+      ^^^^^^^^^^^^^^^^^^ Do not use multiple top-level example groups - try to nest them.
+      describe 'MyOtherClass' do; end
+    RUBY
+  end
 
+  it 'flags multiple top-level example groups aliases' do
+    expect_offense(<<~RUBY)
+      example_group MyClass do; end
+      ^^^^^^^^^^^^^^^^^^^^^ Do not use multiple top-level example groups - try to nest them.
+      feature MyOtherClass do; end
+    RUBY
+  end
+
+  it 'ignores single top-level example group' do
+    expect_no_offenses(<<~RUBY)
+      describe MyClass do
+      end
+    RUBY
+  end
+
+  it 'ignores multiple shared example groups' do
+    expect_no_offenses(<<~RUBY)
+      shared_examples_for 'behaves' do
+      end
+      shared_examples_for 'misbehaves' do
+      end
       describe MyClass do
       end
     RUBY
diff --git a/spec/rubocop/cop/rspec/multiple_expectations_spec.rb b/spec/rubocop/cop/rspec/multiple_expectations_spec.rb
index ded0b91a9..32e8a43a0 100644
--- a/spec/rubocop/cop/rspec/multiple_expectations_spec.rb
+++ b/spec/rubocop/cop/rspec/multiple_expectations_spec.rb
@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::MultipleExpectations do
   context 'without configuration' do
     let(:cop_config) { {} }
 
     it 'flags multiple expectations' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect twice' do
           ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -19,7 +17,7 @@
     end
 
     it 'approves of one expectation per example' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           it 'does something neat' do
             expect(neat).to be(true)
@@ -33,7 +31,7 @@
     end
 
     it 'flags multiple expect_any_instance_of' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect_any_instance_of twice' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -45,7 +43,7 @@
     end
 
     it 'flags multiple is_expected' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect_any_instance_of twice' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -57,7 +55,7 @@
     end
 
     it 'flags multiple expects with blocks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect with block twice' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -69,7 +67,7 @@
     end
 
     it 'counts aggregate_failures as one expectation' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           it 'aggregates failures' do
             aggregate_failures do
@@ -82,7 +80,7 @@
     end
 
     it 'counts every aggregate_failures as an expectation' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'has multiple aggregate_failures calls' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -98,7 +96,7 @@
 
   context 'with metadata' do
     it 'ignores examples with `:aggregate_failures`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           it 'uses expect twice', :foo, :aggregate_failures do
             expect(foo).to eq(bar)
@@ -109,7 +107,7 @@
     end
 
     it 'ignores example groups with `:aggregate_failures`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo, :foo, :aggregate_failures do
           it 'uses expect twice' do
             expect(foo).to eq(bar)
@@ -120,7 +118,7 @@
     end
 
     it 'ignores examples with `aggregate_failures: true`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           it 'uses expect twice', :foo, bar: 1, aggregate_failures: true do
             expect(foo).to eq(bar)
@@ -131,7 +129,7 @@
     end
 
     it 'ignores example groups with `aggregate_failures: true`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo, :foo, bar: 1, aggregate_failures: true do
           it 'uses expect twice' do
             expect(foo).to eq(bar)
@@ -142,7 +140,7 @@
     end
 
     it 'prefers example metadata over example group metadata' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo, aggregate_failures: true do
           it 'uses expect twice', aggregate_failures: false do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -154,7 +152,7 @@
     end
 
     it 'checks examples with `aggregate_failures: false`' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect twice', aggregate_failures: false do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -166,7 +164,7 @@
     end
 
     it 'checks example groups with `aggregate_failures: false`' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo, aggregate_failures: false do
           it 'uses expect twice' do
           ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -178,7 +176,7 @@
     end
 
     it 'checks examples with siblings with `aggregate_failures: true`' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect twice' do
           ^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [2/1].
@@ -194,7 +192,7 @@
     end
 
     it 'ignores examples with `aggregate_failures: true` defined deeply' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Bar, aggregate_failures: true do
           describe Foo do
             it 'uses expect twice' do
@@ -216,7 +214,7 @@
     end
 
     it 'permits two expectations' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         describe Foo do
           it 'uses expect twice' do
             expect(foo).to eq(bar)
@@ -227,7 +225,7 @@
     end
 
     it 'flags three expectations' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe Foo do
           it 'uses expect three times' do
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Example has too many expectations [3/2].
@@ -240,8 +238,8 @@
     end
   end
 
-  it 'generates a todo based on the worst violation' do
-    inspect_source(<<-RUBY, 'spec/foo_spec.rb')
+  it 'generates a todo based on the worst offense' do
+    inspect_source(<<~RUBY, 'spec/foo_spec.rb')
       describe Foo do
         it 'uses expect twice' do
           expect(foo).to eq(bar)
diff --git a/spec/rubocop/cop/rspec/multiple_memoized_helpers_spec.rb b/spec/rubocop/cop/rspec/multiple_memoized_helpers_spec.rb
new file mode 100644
index 000000000..c0ab30dd0
--- /dev/null
+++ b/spec/rubocop/cop/rspec/multiple_memoized_helpers_spec.rb
@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::MultipleMemoizedHelpers do
+  let(:cop_config) { { 'Max' => 1 } }
+
+  it 'flags excessive `#let`' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+      ^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+        let(:foo) { Foo.new }
+        let(:bar) { Bar.new }
+      end
+    RUBY
+  end
+
+  it 'flags excessive `#let!`' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+      ^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+        let(:foo) { Foo.new }
+        let!(:bar) { Bar.new }
+      end
+    RUBY
+  end
+
+  it 'ignores a reasonable number of memoized helpers' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        let(:foo) { Foo.new }
+      end
+    RUBY
+  end
+
+  it 'ignores overridden `#let`' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        let(:foo) { Foo.new }
+        context do
+          let(:foo) { Foo.new(1) }
+          context do
+            let(:foo) { Foo.new(1, 2) }
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores `#subject`' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        subject(:bar) { Bar.new }
+        let(:foo) { Foo.new }
+      end
+    RUBY
+  end
+
+  it 'ignores `#subject!`' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        subject!(:bar) { Bar.new }
+        let(:foo) { Foo.new }
+      end
+    RUBY
+  end
+
+  it 'ignores `#subject` without a name' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        subject { Foo.new }
+        let(:bar) { Bar.new }
+      end
+    RUBY
+  end
+
+  it 'flags nested `#let`' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        let(:foo) { Foo.new }
+
+        context 'when blah' do
+        ^^^^^^^^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+          let(:bar) { Bar.new }
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores distributed `#let`' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        context 'when bloo' do
+          let(:foo) { Foo.new }
+        end
+
+        context 'when blah' do
+          let(:bar) { Bar.new }
+        end
+      end
+    RUBY
+  end
+
+  context 'when using AllowSubject configuration' do
+    let(:cop_config) { { 'Max' => 1, 'AllowSubject' => false } }
+
+    it 'flags `#subject` without name' do
+      expect_offense(<<~RUBY)
+        describe Foo do
+        ^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+          subject { Foo.new }
+          let(:foo) { Foo.new }
+        end
+      RUBY
+    end
+
+    it 'flags `#subject`' do
+      expect_offense(<<~RUBY)
+        describe Foo do
+        ^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+          subject(:foo) { Foo.new }
+          let(:bar) { Foo.new }
+        end
+      RUBY
+    end
+
+    it 'flags `#subject!`' do
+      expect_offense(<<~RUBY)
+        describe Foo do
+        ^^^^^^^^^^^^^^^ Example group has too many memoized helpers [2/1]
+          subject!(:foo) { Foo.new }
+          let(:bar) { Foo.new }
+        end
+      RUBY
+    end
+
+    it 'ignores overridden subjects' do
+      expect_no_offenses(<<~RUBY)
+        describe Foo do
+          subject { Foo.new }
+          context do
+            subject { Foo.new(1) }
+            context do
+              subject { Foo.new(1, 2) }
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  it 'support --auto-gen-config' do
+    inspect_source(<<~RUBY, 'spec/foo_spec.rb')
+      describe Foo do
+        let(:foo) { Foo.new }
+        let(:bar) { Bar.new }
+        let(:baz) { Baz.new }
+        let(:qux) { Qux.new }
+      end
+    RUBY
+
+    expect(cop.config_to_allow_offenses[:exclude_limit]).to eq('Max' => 4)
+  end
+end
diff --git a/spec/rubocop/cop/rspec/multiple_subjects_spec.rb b/spec/rubocop/cop/rspec/multiple_subjects_spec.rb
index 9b87ce78b..f09e206bb 100644
--- a/spec/rubocop/cop/rspec/multiple_subjects_spec.rb
+++ b/spec/rubocop/cop/rspec/multiple_subjects_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::MultipleSubjects do
-  let(:cop) { described_class.new }
-
   it 'registers an offense for every overwritten subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'hello there' do
         subject(:foo) { 1 }
         ^^^^^^^^^^^^^^^^^^^ Do not set more than one subject per example group
@@ -20,7 +18,7 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       describe 'hello there' do
         let(:foo) { 1 }
         let(:bar) { 2 }
@@ -34,7 +32,7 @@
   end
 
   it 'does not try to autocorrect subject!' do
-    source = <<-RUBY
+    source = <<~RUBY
       describe Foo do
         subject! { a }
         ^^^^^^^^^^^^^^ Do not set more than one subject per example group
@@ -43,11 +41,12 @@
     RUBY
 
     expect_offense(source)
+
     expect_no_corrections
   end
 
   it 'does not flag shared example groups' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         it_behaves_like 'user' do
           subject { described_class.new(user, described_class) }
@@ -65,7 +64,7 @@
   end
 
   it 'autocorrects' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'hello there' do
         subject { 1 }
         ^^^^^^^^^^^^^ Do not set more than one subject per example group
@@ -74,7 +73,8 @@
         subject { 3 }
       end
     RUBY
-    expect_correction(<<-RUBY)
+
+    expect_correction(<<~RUBY)
       describe 'hello there' do
         subject { 3 }
       end
diff --git a/spec/rubocop/cop/rspec/named_subject_spec.rb b/spec/rubocop/cop/rspec/named_subject_spec.rb
index a4bda0014..9b02677f0 100644
--- a/spec/rubocop/cop/rspec/named_subject_spec.rb
+++ b/spec/rubocop/cop/rspec/named_subject_spec.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::NamedSubject, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
   shared_examples_for 'checking subject outside of shared examples' do
     it 'checks `it` and `specify` for explicit subject usage' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.describe User do
           subject { described_class.new }
 
@@ -23,7 +21,7 @@
     end
 
     it 'checks before and after for explicit subject usage' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.describe User do
           subject { described_class.new }
 
@@ -41,7 +39,7 @@
     end
 
     it 'checks around(:each) for explicit subject usage' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.describe User do
           subject { described_class.new }
 
@@ -54,7 +52,7 @@
     end
 
     it 'ignores subject when not wrapped inside a test' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         def foo
           it(subject)
         end
@@ -62,13 +60,118 @@ def foo
     end
   end
 
+  context 'when EnforcedStyle is :named_only' do
+    let(:cop_config) { { 'EnforcedStyle' => :named_only } }
+
+    it 'ignores subject where declaration is not named' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          subject { described_class.new }
+
+          it "is a User" do
+            expect(subject).to be_a(User)
+          end
+
+          it "is valid" do
+            expect(subject.valid?).to be(true)
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores subject! where declaration is not named' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          subject! { described_class.new }
+
+          it "is a User" do
+            expect(subject).to be_a(User)
+          end
+
+          it "is valid" do
+            expect(subject.valid?).to be(true)
+          end
+        end
+      RUBY
+    end
+
+    it 'checks subject where declaration is named' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          subject(:new_user) { described_class.new }
+
+          it "is a User" do
+            expect(subject).to be_a(User)
+                   ^^^^^^^ Name your test subject if you need to reference it explicitly.
+          end
+
+          it "is valid" do
+            expect(subject.valid?).to be(true)
+                   ^^^^^^^ Name your test subject if you need to reference it explicitly.
+          end
+        end
+      RUBY
+    end
+
+    it 'checks subject! where declaration is named' do
+      expect_offense(<<~RUBY)
+        RSpec.describe User do
+          subject!(:new_user) { described_class.new }
+
+          it "is a User" do
+            expect(subject).to be_a(User)
+                   ^^^^^^^ Name your test subject if you need to reference it explicitly.
+          end
+
+          it "is valid" do
+            expect(subject.valid?).to be(true)
+                   ^^^^^^^ Name your test subject if you need to reference it explicitly.
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores subject where the closest declaration is not named' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe User do
+          subject(:user) { described_class.new }
+
+          describe 'valid' do
+            subject(:valid) { described_class.new.valid? }
+
+            it 'is valid' do
+              expect(valid).to be(true)
+            end
+          end
+
+          describe 'age' do
+            subject { user.age }
+            it 'allows driving a car' do
+              expect(subject.can_drive_a_car).to be(true)
+            end
+          end
+        end
+      RUBY
+    end
+
+    it 'ignores subject when block has no body' do
+      expect_no_offenses(<<~RUBY)
+        it "is a User" do
+          subject.each do
+            # empty body
+          end
+        end
+      RUBY
+    end
+  end
+
   context 'when IgnoreSharedExamples is false' do
     let(:cop_config) { { 'IgnoreSharedExamples' => false } }
 
     it_behaves_like 'checking subject outside of shared examples'
 
     it 'checks shared_examples for explicit subject usage' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         RSpec.describe User do
           subject(:new_user) { described_class.new }
 
@@ -82,11 +185,6 @@ def foo
               expect(subject.valid?).to be(true)
                      ^^^^^^^ Name your test subject if you need to reference it explicitly.
             end
-
-            it "is new" do
-              expect(subject).to be_new_record
-                     ^^^^^^^ Name your test subject if you need to reference it explicitly.
-            end
           end
         end
       RUBY
@@ -99,7 +197,7 @@ def foo
     it_behaves_like 'checking subject outside of shared examples'
 
     it 'ignores explicit subject in shared_examples' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         RSpec.describe User do
           subject(:new_user) { described_class.new }
 
@@ -111,10 +209,6 @@ def foo
             it "is valid" do
               expect(subject.valid?).to be(true)
             end
-
-            it "is new" do
-              expect(subject).to be_new_record
-            end
           end
         end
       RUBY
diff --git a/spec/rubocop/cop/rspec/nested_groups_spec.rb b/spec/rubocop/cop/rspec/nested_groups_spec.rb
index 48b01b168..bbc37d978 100644
--- a/spec/rubocop/cop/rspec/nested_groups_spec.rb
+++ b/spec/rubocop/cop/rspec/nested_groups_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::NestedGroups, :config do
-  subject(:cop) { described_class.new(config) }
-
-  it 'flags nested contexts' do
-    expect_offense(<<-RUBY)
+RSpec.describe RuboCop::Cop::RSpec::NestedGroups do
+  it 'flags nested example groups defined inside `describe`' do
+    expect_offense(<<~RUBY)
       describe MyClass do
         context 'when foo' do
           context 'when bar' do
@@ -22,8 +20,38 @@
     RUBY
   end
 
+  it 'flags nested example groups' do
+    expect_offense(<<~RUBY)
+      example_group MyClass do
+        context 'when foo' do
+          context 'when bar' do
+            context 'when baz' do
+            ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+            end
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'flags nested example groups inside shared examples' do
+    expect_offense(<<~RUBY)
+      shared_examples_for 'nested like express' do
+        context 'when foo' do
+          context 'when bar' do
+            context 'when baz' do
+              context 'when qux' do
+              ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+              end
+            end
+          end
+        end
+      end
+    RUBY
+  end
+
   it 'support --auto-gen-config' do
-    inspect_source(<<-RUBY, 'spec/foo_spec.rb')
+    inspect_source(<<~RUBY, 'spec/foo_spec.rb')
       describe MyClass do
         context 'when foo' do
           context 'when bar' do
@@ -37,11 +65,32 @@
     expect(cop.config_to_allow_offenses[:exclude_limit]).to eq('Max' => 4)
   end
 
-  it 'ignores non-spec context methods' do
-    expect_no_offenses(<<-RUBY)
+  it 'flags example groups wrapped in classes' do
+    expect_offense(<<~RUBY)
       class MyThingy
-        context 'this is not rspec' do
-          context 'but it uses contexts' do
+        describe MyClass do
+          context 'when foo' do
+            context 'when bar' do
+              context 'when baz' do
+              ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+              end
+            end
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'flags example groups wrapped in modules' do
+    expect_offense(<<~RUBY)
+      module MyNamespace
+        describe MyClass do
+          context 'when foo' do
+            context 'when bar' do
+              context 'when baz' do
+              ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+              end
+            end
           end
         end
       end
@@ -52,7 +101,7 @@ class MyThingy
     let(:cop_config) { { 'Max' => '2' } }
 
     it 'flags two levels of nesting' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         describe MyClass do
           context 'when foo' do
             context 'when bar' do
@@ -78,4 +127,61 @@ class MyThingy
         ).to_stderr
     end
   end
+
+  it 'counts nesting correctly when non-spec nesting' do
+    expect_offense(<<~RUBY)
+      describe MyClass do
+        context 'when foo' do
+          context 'when bar' do
+            [].each do |i|
+              context 'when baz' do
+              ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+              end
+            end
+          end
+        end
+      end
+    RUBY
+  end
+
+  context 'when AllowedGroups is configured as' do
+    let(:cop_config) { { 'AllowedGroups' => ['path'] } }
+
+    before do
+      other_cops
+        .dig('RSpec', 'Language', 'ExampleGroups', 'Regular')
+        .push('path')
+    end
+
+    it 'accept nested example groups defined inside `describe`' \
+       'path is not counted' do
+      expect_no_offenses(<<~RUBY)
+        describe MyClass do
+          path '/users' do
+            context 'when foo' do
+              context 'when bar' do
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    it 'flags nested example groups defined inside `describe`' \
+       'path is not counted but exceeded max' do
+      expect_offense(<<~RUBY)
+        describe MyClass do
+          path '/users' do
+            context 'when foo' do
+              context 'when bar' do
+                context 'when baz' do
+                ^^^^^^^^^^^^^^^^^^ Maximum example group nesting exceeded [4/3].
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/no_expectation_example_spec.rb b/spec/rubocop/cop/rspec/no_expectation_example_spec.rb
new file mode 100644
index 000000000..06c7e5221
--- /dev/null
+++ b/spec/rubocop/cop/rspec/no_expectation_example_spec.rb
@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::NoExpectationExample do
+  context 'with no expectation example with it' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          it { bar }
+          ^^^^^^^^^^ No expectation found in this example.
+
+          it { expect(baz).to be_truthy }
+        end
+      RUBY
+    end
+  end
+
+  context 'with no expectation example with specify' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY)
+        specify { bar }
+        ^^^^^^^^^^^^^^^ No expectation found in this example.
+      RUBY
+    end
+  end
+
+  context 'with expectation example with should' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        it { should be_truthy }
+      RUBY
+    end
+  end
+
+  context 'with multi no expectation examples' do
+    it 'registers offenses' do
+      expect_offense(<<~RUBY)
+        it { bar }
+        ^^^^^^^^^^ No expectation found in this example.
+        it { baz }
+        ^^^^^^^^^^ No expectation found in this example.
+      RUBY
+    end
+  end
+
+  context 'with custom expectation example' do
+    it 'registers an offense' do
+      expect_offense(<<~RUBY)
+        it { custom_expect(bar) }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^ No expectation found in this example.
+      RUBY
+    end
+  end
+
+  context 'with configured custom expectation example' do
+    before do
+      other_cops.dig('RSpec', 'Language', 'Expectations').push('custom_expect')
+    end
+
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        it { custom_expect(bar) }
+      RUBY
+    end
+  end
+
+  context 'with no expectation custom example' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        custom_it { foo }
+      RUBY
+    end
+  end
+
+  context 'with no expectation configured custom example' do
+    before do
+      other_cops.dig(
+        'RSpec',
+        'Language',
+        'Examples',
+        'Regular'
+      ).push('custom_it')
+    end
+
+    it 'registers an offense' do
+      expect_offense(<<~RUBY)
+        custom_it { foo }
+        ^^^^^^^^^^^^^^^^^ No expectation found in this example.
+      RUBY
+    end
+  end
+
+  context 'with block-less example in block' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'not implemented'
+        end
+      RUBY
+    end
+  end
+
+  context 'with no expectation pending example' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        pending { bar }
+      RUBY
+    end
+  end
+
+  context 'with no expectation skipped example' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        skip { bar }
+      RUBY
+    end
+  end
+
+  context 'with no expectation pending example when using `pending` ' \
+          'inside an example' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        it "is implemented but waiting" do
+          pending "something else getting finished"
+        end
+      RUBY
+    end
+  end
+
+  context 'with no expectation skipped example when using `skip` ' \
+          'inside an example' do
+    it 'registers no offenses' do
+      expect_no_offenses(<<~RUBY)
+        it "is skipped" do
+          skip
+        end
+      RUBY
+    end
+  end
+
+  it 'registers no offense for skipped/pending with metadata' do
+    expect_no_offenses(<<~RUBY)
+      it 'is skipped', :skip do
+        foo
+      end
+      it 'is skipped', skip: true do
+        foo
+      end
+      it 'is skipped', skip: "test" do
+        foo
+      end
+      it 'is skipped', skip: "test" \\
+                             "foo" do
+        foo
+      end
+      it 'is pending', :pending do
+        foo
+      end
+      it 'is pending', pending: true do
+        foo
+      end
+      it 'is pending', pending: "test" do
+        foo
+      end
+      it 'is pending', pending: "test" \\
+                                "foo" do
+        foo
+      end
+    RUBY
+  end
+
+  context 'when `AllowedPatterns: [^expect_]`' do
+    let(:cop_config) { { 'AllowedPatterns' => ['^expect_'] } }
+
+    context 'when only allowed pattern methods are used' do
+      it 'registers no offenses' do
+        expect_no_offenses(<<~RUBY)
+          it { expect_something }
+        RUBY
+      end
+    end
+
+    context 'when only allowed pattern methods with arguments are used' do
+      it 'registers no offenses' do
+        expect_no_offenses(<<~RUBY)
+          it { expect_something(foo, bar) }
+          it { expect_something(foo, bar, baz) }
+        RUBY
+      end
+    end
+
+    context 'when allowed pattern methods and other method are used' do
+      it 'registers no offenses' do
+        expect_no_offenses(<<~RUBY)
+          it do
+            do_something
+            expect_something
+            do_something
+          end
+        RUBY
+      end
+    end
+
+    context 'when nested allowed pattern methods and other method are used' do
+      it 'registers no offenses' do
+        expect_no_offenses(<<~RUBY)
+          it do
+            do_something
+            some_patterns.each do
+              expect_something
+            end
+            do_something
+          end
+        RUBY
+      end
+    end
+
+    context 'when only not allowed pattern methods are used' do
+      it 'does something' do
+        expect_offense(<<~RUBY)
+          it { not_expect_something }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ No expectation found in this example.
+        RUBY
+      end
+    end
+  end
+
+  context 'when Ruby 2.7', :ruby27 do
+    context 'with no expectation example with it' do
+      it 'registers an offense' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            it { _1 }
+            ^^^^^^^^^ No expectation found in this example.
+
+            it { expect(baz).to be_truthy }
+          end
+        RUBY
+      end
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/not_to_not_spec.rb b/spec/rubocop/cop/rspec/not_to_not_spec.rb
index 2e937f158..745235039 100644
--- a/spec/rubocop/cop/rspec/not_to_not_spec.rb
+++ b/spec/rubocop/cop/rspec/not_to_not_spec.rb
@@ -1,31 +1,29 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::NotToNot, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::NotToNot do
   context 'when EnforcedStyle is `not_to`' do
     let(:cop_config) { { 'EnforcedStyle' => 'not_to' } }
 
     it 'detects the `to_not` offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { expect(false).to_not be_true }
                            ^^^^^^ Prefer `not_to` over `to_not`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { expect(false).not_to be_true }
       RUBY
     end
 
     it 'detects the `to_not` offense on an expect block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect {
           2 + 2
         }.to_not raise_error
           ^^^^^^ Prefer `not_to` over `to_not`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         expect {
           2 + 2
         }.not_to raise_error
@@ -33,7 +31,7 @@
     end
 
     it 'detects no offense when using `not_to`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it { expect(false).not_to be_true }
       RUBY
     end
@@ -43,25 +41,25 @@
     let(:cop_config) { { 'EnforcedStyle' => 'to_not' } }
 
     it 'detects the `not_to` offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it { expect(false).not_to be_true }
                            ^^^^^^ Prefer `to_not` over `not_to`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it { expect(false).to_not be_true }
       RUBY
     end
 
     it 'detects the `not_to` offense on an expect block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect {
           2 + 2
         }.not_to raise_error
           ^^^^^^ Prefer `to_not` over `not_to`.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         expect {
           2 + 2
         }.to_not raise_error
@@ -69,7 +67,7 @@
     end
 
     it 'detects no offense when using `to_not`' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it { expect(false).to_not be_true }
       RUBY
     end
diff --git a/spec/rubocop/cop/rspec/overwriting_setup_spec.rb b/spec/rubocop/cop/rspec/overwriting_setup_spec.rb
index 865e0b95e..a424206f7 100644
--- a/spec/rubocop/cop/rspec/overwriting_setup_spec.rb
+++ b/spec/rubocop/cop/rspec/overwriting_setup_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::OverwritingSetup do
-  subject(:cop) { described_class.new }
-
-  it 'finds overwriten `let`' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for overwritten `let`' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
         let(:a) { b }
@@ -13,8 +11,8 @@
     RUBY
   end
 
-  it 'finds overwriten `subject`' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for overwritten `subject`' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject(:a) { a }
 
@@ -24,8 +22,8 @@
     RUBY
   end
 
-  it 'works with `subject!` and `let!`' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for `subject!` and `let!`' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject!(:a) { a }
 
@@ -35,8 +33,8 @@
     RUBY
   end
 
-  it 'finds `let!` overwriting `let`' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for `let!` overwriting `let`' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         let(:a) { b }
         let!(:a) { b }
@@ -45,8 +43,8 @@
     RUBY
   end
 
-  it 'ignores overwriting in different context' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for overwriting in different context' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
 
@@ -57,8 +55,8 @@
     RUBY
   end
 
-  it 'handles unnamed subjects' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for overriding an unnamed subject' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject { a }
 
@@ -68,8 +66,8 @@
     RUBY
   end
 
-  it 'handles dynamic names for `let`' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense for dynamic names for `let`' do
+    expect_no_offenses(<<~RUBY)
       RSpec.describe User do
         subject(:name) { a }
 
@@ -78,8 +76,8 @@
     RUBY
   end
 
-  it 'handles string arguments' do
-    expect_offense(<<-RUBY)
+  it 'registers an offense for string arguments' do
+    expect_offense(<<~RUBY)
       RSpec.describe User do
         subject(:name) { a }
 
diff --git a/spec/rubocop/cop/rspec/pending_spec.rb b/spec/rubocop/cop/rspec/pending_spec.rb
index f3db64731..14b09f316 100644
--- a/spec/rubocop/cop/rspec/pending_spec.rb
+++ b/spec/rubocop/cop/rspec/pending_spec.rb
@@ -1,10 +1,24 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::Pending do
-  subject(:cop) { described_class.new }
+  it 'flags it without body' do
+    expect_offense(<<~RUBY)
+      it 'test'
+      ^^^^^^^^^ Pending spec found.
+    RUBY
+  end
+
+  it 'flags it without body inside describe block' do
+    expect_offense(<<~RUBY)
+      describe 'test' do
+        it 'test'
+        ^^^^^^^^^ Pending spec found.
+      end
+    RUBY
+  end
 
   it 'flags xcontext' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xcontext 'test' do
       ^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -12,7 +26,7 @@
   end
 
   it 'flags xdescribe' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xdescribe 'test' do
       ^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -20,7 +34,7 @@
   end
 
   it 'flags xexample' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xexample 'test' do
       ^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -28,7 +42,7 @@
   end
 
   it 'flags xfeature' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xfeature 'test' do
       ^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -36,7 +50,7 @@
   end
 
   it 'flags xit' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xit 'test' do
       ^^^^^^^^^^ Pending spec found.
       end
@@ -44,7 +58,7 @@
   end
 
   it 'flags xscenario' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xscenario 'test' do
       ^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -52,7 +66,7 @@
   end
 
   it 'flags xspecify' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       xspecify 'test' do
       ^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -60,7 +74,7 @@
   end
 
   it 'flags skip inside of an it' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'test' do
         skip
         ^^^^ Pending spec found.
@@ -69,7 +83,7 @@
   end
 
   it 'flags skip blocks' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       skip 'test' do
       ^^^^^^^^^^^ Pending spec found.
       end
@@ -77,7 +91,7 @@
   end
 
   it 'flags blocks with skip symbol metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'test', :skip do
       ^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -85,7 +99,7 @@
   end
 
   it 'flags describe with skip symbol metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe 'test', :skip do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -93,15 +107,43 @@
   end
 
   it 'flags blocks with pending symbol metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'test', :pending do
       ^^^^^^^^^^^^^^^^^^^ Pending spec found.
       end
     RUBY
   end
 
+  it 'flags blocks with pending: string metadata and line break by `\`' do
+    expect_offense(<<~'RUBY')
+      it "test", pending: 'test' \
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
+                          'foo' do
+      end
+    RUBY
+  end
+
+  it 'flags blocks with pending: string metadata and line break by `,`' do
+    expect_offense(<<~RUBY)
+      it "test", pending: 'test ,
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
+                          foo' do
+      end
+    RUBY
+  end
+
+  it 'flags blocks with pending: surrounded by `%()` string metadata ' \
+     'and line break' do
+    expect_offense(<<~RUBY)
+      it "test", pending: %(test ,
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
+                          foo) do
+      end
+    RUBY
+  end
+
   it 'flags blocks with skip: true metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'test', skip: true do
       ^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -109,7 +151,7 @@
   end
 
   it 'flags blocks with skip: string metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'test', skip: 'skipped because of being slow' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Pending spec found.
       end
@@ -117,78 +159,78 @@
   end
 
   it 'flags pending blocks' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       pending 'test' do
       ^^^^^^^^^^^^^^ Pending spec found.
       end
     RUBY
   end
 
-  it 'flags pending examples when receiver is explicit' do
-    expect_offense(<<-RUBY)
-      RSpec.xit 'test' do
-      ^^^^^^^^^^^^^^^^ Pending spec found.
-      end
-    RUBY
-  end
-
   it 'ignores describe' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'test' do; end
     RUBY
   end
 
   it 'ignores example' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       example 'test' do; end
     RUBY
   end
 
   it 'ignores scenario' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       scenario 'test' do; end
     RUBY
   end
 
   it 'ignores specify' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       specify do; end
     RUBY
   end
 
   it 'ignores feature' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       feature 'test' do; end
     RUBY
   end
 
   it 'ignores context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context 'test' do; end
     RUBY
   end
 
   it 'ignores it' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'test' do; end
     RUBY
   end
 
   it 'ignores it with skip: false metadata' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'test', skip: false do; end
     RUBY
   end
 
   it 'ignores example_group' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       example_group 'test' do; end
     RUBY
   end
 
   it 'ignores method called pending' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       subject { Project.pending }
     RUBY
   end
+
+  it 'ignores default block parameter' do
+    expect_no_offenses(<<~RUBY)
+      expect(
+        foo.map { it.reverse }
+      ).to include(:bar)
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/pending_without_reason_spec.rb b/spec/rubocop/cop/rspec/pending_without_reason_spec.rb
new file mode 100644
index 000000000..4c6a70f91
--- /dev/null
+++ b/spec/rubocop/cop/rspec/pending_without_reason_spec.rb
@@ -0,0 +1,403 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::PendingWithoutReason, :ruby27 do
+  context 'when pending/skip has a reason inside an example' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~'RUBY')
+        RSpec.describe Foo do
+          it 'does something' do
+            pending 'reason'
+            pending "#{reason}"
+            pending `echo #{reason}`
+            skip 'reason'
+            skip "#{reason}"
+            skip `echo #{reason}`
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip has a reason inside an example group' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          skip 'does something'
+          pending 'does something'
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip has a reason inside a shared example group' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          shared_examples 'something' do
+            pending 'does something'
+            skip 'does something'
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip by metadata on example with reason' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something', pending: 'reason' do
+          end
+          it 'does something', skip: 'reason' do
+          end
+          it 'does something', pending: 'reason' do
+            _1
+          end
+          it 'does something', skip: 'reason' do
+            _1
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip by metadata on example group with reason' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        describe 'something', pending: 'reason' do
+        end
+        describe 'something', skip: 'reason' do
+        end
+        describe 'something', pending: 'reason' do
+          _1
+        end
+        describe 'something', skip: 'reason' do
+          _1
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip not inside an example' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        FactoryBot.define do
+          factory :task do
+            pending
+            skip
+            pending { true }
+            skip { true }
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip with receiver' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            Foo.pending
+            Foo.skip
+          end
+          it 'does something' do
+            _1.pending
+            _1.skip
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip is an argument' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            expect('foo').to eq(pending)
+            expect('foo').to eq(skip)
+            foo(bar, pending, skip)
+            foo(bar, pending: pending, skip: skip)
+            is_expected.to match_array([foo, pending, skip, bar])
+            list = [skip, pending]
+            foo(list)
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip by example method with block' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          pending 'does something' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+          end
+          skip 'does something' do
+          ^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          end
+          skip 'does something' do
+          ^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+            _1
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending inside an example with a block' do
+    it 'registers no offense' do
+      # `ArgumentError` is raised when block is given to `pending` inside
+      # an example.
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            pending 'does something' do
+              do_something
+            end
+            pending 'does something' do
+              _1.do_something
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when skip inside an example with a block' do
+    it 'registers no offense' do
+      # RSpec ignores the block
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            skip 'does something' do
+              do_something
+            end
+            skip 'does something' do
+              _1.do_something
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip by metadata on example without reason' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something', :pending do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+          end
+          it 'does something', :skip do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          end
+          it 'does something', pending: true do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+          end
+          it 'does something', skip: true do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          end
+          it 'does something', :pending do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+            _1
+          end
+          it 'does something', :skip do
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+            _1
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip by metadata on example group without reason' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        describe 'something', :pending do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+        end
+        describe 'something', :skip do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+        end
+        describe 'something', pending: true do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+        end
+        describe 'something', skip: true do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+        end
+        describe 'something', :pending do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+          _1
+        end
+        describe 'something', :skip do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          _1
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip without reason' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          pending
+          ^^^^^^^ Give the reason for pending.
+          skip
+          ^^^^ Give the reason for skip.
+        end
+        RSpec.describe Foo do
+          context 'when something' do
+            pending
+            ^^^^^^^ Give the reason for pending.
+          end
+          context 'when something' do
+            skip
+            ^^^^ Give the reason for skip.
+          end
+        end
+        RSpec.describe Foo do
+          it 'does something' do
+            pending
+            ^^^^^^^ Give the reason for pending.
+          end
+          it 'does something' do
+            skip
+            ^^^^ Give the reason for skip.
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip without reason with other statement' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          before { buzz! }
+          pending
+          ^^^^^^^ Give the reason for pending.
+          skip
+          ^^^^ Give the reason for skip.
+          context 'when something' do
+            let(:foo) { 'bar' }
+            pending
+            ^^^^^^^ Give the reason for pending.
+            skip
+            ^^^^ Give the reason for skip.
+            it 'does something' do
+              do_something
+              pending
+              ^^^^^^^ Give the reason for pending.
+              skip
+              ^^^^ Give the reason for skip.
+              do_something
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when pending/skip inside conditional' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            pending if RUBY_VERSION < '3.0'
+            if RUBY_VERSION < '3.0'
+              skip
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when skipped by example group method' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe 'Foo' do
+          xdescribe 'something' do
+          ^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          end
+          xdescribe 'something' do
+          ^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+            _1.do_something
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when skipped by top-level example group' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.xdescribe 'something' do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+        end
+        RSpec.xdescribe 'something' do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          _1.do_something
+        end
+      RUBY
+    end
+  end
+
+  context 'when skipped by example method' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe 'Foo' do
+          skip 'does something' do
+          ^^^^^^^^^^^^^^^^^^^^^ Give the reason for skip.
+          end
+          xit 'something' do
+          ^^^^^^^^^^^^^^^ Give the reason for xit.
+          end
+          xit 'something' do
+          ^^^^^^^^^^^^^^^ Give the reason for xit.
+            _1.do_something
+          end
+          pending 'does something' do
+          ^^^^^^^^^^^^^^^^^^^^^^^^ Give the reason for pending.
+            _1
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when skipped inside an example' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          it 'does something' do
+            skip 'does something' do
+              do_something
+            end
+            skip 'does something' do
+              _1
+            end
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when skipped inside a shared example group' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          shared_examples 'something' do
+            xit 'something' do
+            ^^^^^^^^^^^^^^^ Give the reason for xit.
+            end
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/predicate_matcher_spec.rb b/spec/rubocop/cop/rspec/predicate_matcher_spec.rb
index 1d1935dda..56885be61 100644
--- a/spec/rubocop/cop/rspec/predicate_matcher_spec.rb
+++ b/spec/rubocop/cop/rspec/predicate_matcher_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::PredicateMatcher, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::PredicateMatcher do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style,
       'Strict' => strict,
@@ -15,164 +13,185 @@
 
     shared_examples 'inflected common' do
       it 'registers an offense for a predicate method in actual' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo.empty?).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to be_truthy, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
           expect(foo.empty?).not_to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
           expect(foo.empty?).to_not be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
           expect(foo.empty?).to be_falsey
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to be_falsey
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to a_truthy_value
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to be_empty
+          expect(foo).to be_empty, 'fail'
+          expect(foo).not_to be_empty
+          expect(foo).not_to be_empty
+          expect(foo).not_to be_empty
+          expect(foo).to be_empty
+          expect(foo).not_to be_empty
         RUBY
       end
 
       it 'registers an offense for a predicate method with built-in equiv' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo.exist?).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `exist` matcher over `exist?`.
+          expect(foo.exist?).to be_truthy, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `exist` matcher over `exist?`.
           expect(foo.exists?).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `exist` matcher over `exists?`.
           expect(foo.has_something?).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `have_something` matcher over `has_something?`.
+          expect(foo.has_something?).not_to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `have_something` matcher over `has_something?`.
           expect(foo.include?(something)).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include` matcher over `include?`.
           expect(foo.respond_to?(:bar)).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `respond_to` matcher over `respond_to?`.
+          expect(foo.something?()).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to exist
+          expect(foo).to exist, 'fail'
+          expect(foo).to exist
+          expect(foo).to have_something
+          expect(foo).not_to have_something
+          expect(foo).to include(something)
+          expect(foo).to respond_to(:bar)
+          expect(foo).to be_something()
+        RUBY
+      end
+
+      it 'accepts respond_to? with a second argument' do
+        expect_no_offenses(<<~RUBY)
+          expect(foo.respond_to?(:bar, true)).to be_truthy
         RUBY
       end
 
       it 'registers an offense for a predicate method with argument' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo.something?('foo')).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+          expect(foo.something?('foo')).to be_truthy, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
           expect(foo.something?('foo', 'bar')).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+          expect(foo.something? 1, 2).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
           expect(foo.has_key?('foo')).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `have_key` matcher over `has_key?`.
+          expect(foo.is_a?(Array)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_a` matcher over `is_a?`.
+          expect(foo.instance_of?(Array)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_an_instance_of` matcher over `instance_of?`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to be_something('foo')
+          expect(foo).to be_something('foo'), 'fail'
+          expect(foo).to be_something('foo', 'bar')
+          expect(foo).to be_something 1, 2
+          expect(foo).to have_key('foo')
+          expect(foo).to be_a(Array)
+          expect(foo).to be_an_instance_of(Array)
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with heredoc' do
+        expect_offense(<<~RUBY)
+          expect(foo.something?(<<~TEXT)).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+            bar
+          TEXT
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to be_something(<<~TEXT)
+            bar
+          TEXT
         RUBY
       end
 
       it 'registers an offense for a predicate method with a block' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo.all?(&:present?)).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.all?(&:present?)).to be_truthy, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
           expect(foo.all? { |x| x.present? }).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.all?(n) { |x| x.present? }).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
           expect(foo.all? { present }).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
           expect(foo.something?(x) { |y| y.present? }).to be_truthy
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_something` matcher over `something?`.
+          expect(foo.all? { }).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+          expect(foo.all? do; end).to be_truthy
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+
+          expect(foo.all? do |x|
+          ^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_all` matcher over `all?`.
+            x + 1
+            x >= 2
+          end).to be_truthy
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo).to be_all(&:present?)
+          expect(foo).to be_all(&:present?), 'fail'
+          expect(foo).to be_all { |x| x.present? }
+          expect(foo).to be_all(n) { |x| x.present? }
+          expect(foo).to be_all { present }
+          expect(foo).to be_something(x) { |y| y.present? }
+          expect(foo).to be_all { }
+          expect(foo).to be_all do; end
+
+          expect(foo).to be_all do |x|
+            x + 1
+            x >= 2
+          end
         RUBY
       end
 
-      it 'accepts a predicate method that is not ckeced true/false' do
-        expect_no_offenses(<<-RUBY)
+      it 'accepts a predicate method that is not checked true/false' do
+        expect_no_offenses(<<~RUBY)
           expect(foo.something?).to eq "something"
+          expect(foo.something?).to eq "something", "fail"
           expect(foo.has_something?).to eq "something"
         RUBY
       end
 
       it 'accepts non-predicate method' do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           expect(foo.something).to be(true)
+          expect(foo.something).to be(true), 'fail'
           expect(foo.has_something).to be(true)
         RUBY
       end
-
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to be_truthy',
-                       'expect(foo).to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).not_to be_truthy',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to_not be_truthy',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to be_falsey',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).not_to be_falsey',
-                       'expect(foo).to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).not_to a_truthy_value',
-                       'expect(foo).not_to be_empty'
-
-      include_examples 'autocorrect',
-                       'expect(foo.is_a?(Array)).to be_truthy',
-                       'expect(foo).to be_a(Array)'
-
-      include_examples 'autocorrect',
-                       'expect(foo.instance_of?(Array)).to be_truthy',
-                       'expect(foo).to be_an_instance_of(Array)'
-
-      include_examples 'autocorrect',
-                       'expect(foo.has_something?).to be_truthy',
-                       'expect(foo).to have_something'
-      include_examples 'autocorrect',
-                       'expect(foo.has_something?).not_to be_truthy',
-                       'expect(foo).not_to have_something'
-      include_examples 'autocorrect',
-                       'expect(foo.include?(something)).to be_truthy',
-                       'expect(foo).to include(something)'
-      include_examples 'autocorrect',
-                       'expect(foo.respond_to?(:bar)).to be_truthy',
-                       'expect(foo).to respond_to(:bar)'
-      include_examples 'autocorrect',
-                       'expect(foo.exists?).to be_truthy',
-                       'expect(foo).to exist'
-
-      include_examples 'autocorrect',
-                       'expect(foo.something?()).to be_truthy',
-                       'expect(foo).to be_something()'
-      include_examples 'autocorrect',
-                       'expect(foo.something? 1, 2).to be_truthy',
-                       'expect(foo).to be_something 1, 2'
-      include_examples 'autocorrect',
-                       'expect(foo.has_key?("foo")).to be_truthy',
-                       'expect(foo).to have_key("foo")'
-      include_examples 'autocorrect',
-                       'expect(foo.something?(1, 2)).to be_truthy',
-                       'expect(foo).to be_something(1, 2)'
-
-      include_examples 'autocorrect',
-                       'expect(foo.all? { |x| x.present? }).to be_truthy',
-                       'expect(foo).to be_all { |x| x.present? }'
-      include_examples 'autocorrect',
-                       'expect(foo.all?(n) { |x| x.present? }).to be_truthy',
-                       'expect(foo).to be_all(n) { |x| x.present? }'
-      include_examples 'autocorrect',
-                       'expect(foo.all? { present }).to be_truthy',
-                       'expect(foo).to be_all { present }'
-      include_examples 'autocorrect',
-                       'expect(foo.all? { }).to be_truthy',
-                       'expect(foo).to be_all { }'
-      include_examples 'autocorrect',
-                       <<-BEFORE, <<-AFTER
-                         expect(foo.all? do |x|
-                           x + 1
-                           x >= 2
-                         end).to be_truthy
-                       BEFORE
-                         expect(foo).to be_all do |x|
-                           x + 1
-                           x >= 2
-                         end
-                       AFTER
-      include_examples 'autocorrect',
-                       'expect(foo.all? do; end).to be_truthy',
-                       'expect(foo).to be_all do; end'
     end
 
     context 'when strict is true' do
       let(:strict) { true }
 
-      include_examples 'inflected common'
+      it_behaves_like 'inflected common'
 
       it 'accepts strict checking boolean matcher' do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           expect(foo.empty?).to eq(true)
+          expect(foo.empty?).to eq(true), 'fail'
           expect(foo.empty?).to be(true)
           expect(foo.empty?).to be(false)
           expect(foo.empty?).not_to be true
@@ -184,12 +203,20 @@
     context 'when strict is false' do
       let(:strict) { false }
 
-      include_examples 'inflected common'
+      it_behaves_like 'inflected common'
 
       it 'registers an offense for a predicate method in actual' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo.empty?).to eq(true)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to eq(true), 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to eql(true)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).to equal(true), 'whoops'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
+          expect(foo.empty?).not_to be(true)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
           expect(foo.empty?).to be(true)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
           expect(foo.empty?).to be(false)
@@ -199,55 +226,62 @@
           expect(foo.empty?).not_to be false
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `be_empty` matcher over `empty?`.
         RUBY
-      end
 
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to eq(true)',
-                       'expect(foo).to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to eq(false)',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to be(true)',
-                       'expect(foo).to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).to be(false)',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).not_to be(true)',
-                       'expect(foo).not_to be_empty'
-      include_examples 'autocorrect',
-                       'expect(foo.empty?).not_to be(false)',
-                       'expect(foo).to be_empty'
+        expect_correction(<<~RUBY)
+          expect(foo).to be_empty
+          expect(foo).to be_empty, 'fail'
+          expect(foo).to be_empty
+          expect(foo).to be_empty, 'whoops'
+          expect(foo).not_to be_empty
+          expect(foo).to be_empty
+          expect(foo).not_to be_empty
+          expect(foo).not_to be_empty
+          expect(foo).to be_empty
+        RUBY
+      end
     end
   end
 
   context 'when enforced style is `explicit`' do
     let(:enforced_style) { 'explicit' }
 
-    shared_examples 'explicit common' do
+    shared_examples 'explicit' do |matcher_true, matcher_false|
       it 'registers an offense for a predicate mather' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo).to be_empty
           ^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `empty?` over `be_empty` matcher.
+          expect(foo).to be_empty, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `empty?` over `be_empty` matcher.
           expect(foo).not_to be_empty
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `empty?` over `be_empty` matcher.
           expect(foo).to have_something
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `has_something?` over `have_something` matcher.
         RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.empty?).to #{matcher_true}
+          expect(foo.empty?).to #{matcher_true}, 'fail'
+          expect(foo.empty?).to #{matcher_false}
+          expect(foo.has_something?).to #{matcher_true}
+        RUBY
       end
 
       it 'registers an offense for a predicate mather with argument' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo).to be_something(1, 2)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
           expect(foo).to have_key(1)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `has_key?` over `have_key` matcher.
         RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.something?(1, 2)).to #{matcher_true}
+          expect(foo.has_key?(1)).to #{matcher_true}
+        RUBY
       end
 
       it 'registers an offense for a predicate matcher with a block' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           expect(foo).to be_all(&:present?)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
           expect(foo).to be_all { |x| x.present? }
@@ -257,11 +291,19 @@
           expect(foo).to be_something(x) { |y| y.present? }
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
         RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.all?(&:present?)).to #{matcher_true}
+          expect(foo.all? { |x| x.present? }).to #{matcher_true}
+          expect(foo.all? { present }).to #{matcher_true}
+          expect(foo.something?(x) { |y| y.present? }).to #{matcher_true}
+        RUBY
       end
 
       it 'accepts built in matchers' do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           expect(foo).to be_truthy
+          expect(foo).to be_truthy, 'fail'
           expect(foo).to be_falsey
           expect(foo).to be_falsy
           expect(foo).to have_attributes(name: 'foo')
@@ -276,91 +318,203 @@
         let(:allowed_explicit_matchers) { ['have_http_status'] }
 
         it 'accepts custom allowed explicit matchers' do
-          expect_no_offenses(<<-RUBY)
+          expect_no_offenses(<<~RUBY)
             expect(foo).to have_http_status(:ok)
           RUBY
         end
       end
 
       it 'accepts non-predicate matcher' do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           expect(foo).to be(true)
+          expect(foo).to be(true), 'fail'
         RUBY
       end
-    end
 
-    shared_examples 'explicit autocorrect' do |matcher_true, matcher_false|
-      include_examples 'autocorrect',
-                       'expect(foo).to be_something',
-                       "expect(foo.something?).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).not_to be_something',
-                       "expect(foo.something?).to #{matcher_false}"
-      include_examples 'autocorrect',
-                       'expect(foo).to have_something',
-                       "expect(foo.has_something?).to #{matcher_true}"
-
-      include_examples 'autocorrect',
-                       'expect(foo).to be_a(Array)',
-                       "expect(foo.is_a?(Array)).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_instance_of(Array)',
-                       "expect(foo.instance_of?(Array)).to #{matcher_true}"
-
-      include_examples 'autocorrect',
-                       'expect(foo).to be_something()',
-                       "expect(foo.something?()).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_something(1)',
-                       "expect(foo.something?(1)).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_something(1, 2)',
-                       "expect(foo.something?(1, 2)).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_something 1, 2',
-                       "expect(foo.something? 1, 2).to #{matcher_true}"
-
-      include_examples 'autocorrect',
-                       'expect(foo).to be_all { |x| x.present? }',
-                       "expect(foo.all? { |x| x.present? }).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_all(n) { |x| x.ok? }',
-                       "expect(foo.all?(n) { |x| x.ok? }).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_all { present }',
-                       "expect(foo.all? { present }).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       'expect(foo).to be_all { }',
-                       "expect(foo.all? { }).to #{matcher_true}"
-      include_examples 'autocorrect',
-                       <<-BEFORE, <<-AFTER
-                         expect(foo).to be_all do |x|
-                           x + 1
-                           x >= 2
-                         end
-                       BEFORE
-                         expect(foo.all? do |x|
-                           x + 1
-                           x >= 2
-                         end).to #{matcher_true}
-                       AFTER
-      include_examples 'autocorrect',
-                       'expect(foo).to be_all do; end',
-                       "expect(foo.all? do; end).to #{matcher_true}"
+      it 'registers an offense for a predicate method with built-in equiv' do
+        expect_offense(<<~RUBY)
+          expect(foo).to be_something
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).to be_something, 'fail'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).not_to be_something
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).to have_something
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `has_something?` over `have_something` matcher.
+          expect(foo).to be_a(Array)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `is_a?` over `be_a` matcher.
+          expect(foo).to be_instance_of(Array)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `instance_of?` over `be_instance_of` matcher.
+          expect(foo).to include('bar')
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+          expect(foo).to respond_to(:method)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `respond_to?` over `respond_to` matcher.
+          expect(foo).to be_something()
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.something?).to #{matcher_true}
+          expect(foo.something?).to #{matcher_true}, 'fail'
+          expect(foo.something?).to #{matcher_false}
+          expect(foo.has_something?).to #{matcher_true}
+          expect(foo.is_a?(Array)).to #{matcher_true}
+          expect(foo.instance_of?(Array)).to #{matcher_true}
+          expect(foo.include?('bar')).to #{matcher_true}
+          expect(foo.respond_to?(:method)).to #{matcher_true}
+          expect(foo.something?()).to #{matcher_true}
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with argument' do
+        expect_offense(<<~RUBY)
+          expect(foo).to be_something(1)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).to be_something(1, 2)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+          expect(foo).to be_something 1, 2
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.something?(1)).to #{matcher_true}
+          expect(foo.something?(1, 2)).to #{matcher_true}
+          expect(foo.something? 1, 2).to #{matcher_true}
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with heredoc' do
+        expect_offense(<<~RUBY)
+          expect(foo).to include(<<~TEXT)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `include?` over `include` matcher.
+            bar
+          TEXT
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.include?(<<~TEXT)).to #{matcher_true}
+            bar
+          TEXT
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc and multiline expect' do
+        expect_offense(<<~RUBY)
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(<<~TEXT)
+              bar
+            TEXT
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(bar, <<~TEXT, 'baz')
+              bar
+            TEXT
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc include #{} and multiline expect' do
+        expect_offense(<<~'RUBY')
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(<<~TEXT)
+              #{bar}
+            TEXT
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(bar, <<~TEXT, 'baz')
+              #{bar}
+            TEXT
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'registers an offense for a predicate method with ' \
+         'heredoc surrounded by back ticks and multiline expect' do
+        expect_offense(<<~RUBY)
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(<<~`COMMAND`)
+              pwd
+            COMMAND
+
+          expect(foo)
+          ^^^^^^^^^^^ Prefer using `something?` over `be_something` matcher.
+            .to be_something(bar, <<~COMMAND, 'baz')
+              pwd
+            COMMAND
+        RUBY
+
+        expect_no_corrections
+      end
+
+      it 'does not register an offense for a `include` ' \
+         'with no argument' do
+        expect_no_offenses(<<~RUBY)
+          expect(foo).to include
+          expect(foo).to include, 'fail'
+        RUBY
+      end
+
+      it 'does not register an offense for a `include` ' \
+         'with multiple arguments' do
+        expect_no_offenses(<<~RUBY)
+          expect(foo).to include(foo, bar)
+        RUBY
+      end
+
+      it 'registers an offense for a predicate method with a block' do
+        expect_offense(<<~RUBY)
+          expect(foo).to be_all { |x| x.present? }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all(n) { |x| x.ok? }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all { present }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all { }
+          ^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+          expect(foo).to be_all do; end
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+
+          expect(foo).to be_all do |x|
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer using `all?` over `be_all` matcher.
+            x + 1
+            x >= 2
+          end
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(foo.all? { |x| x.present? }).to #{matcher_true}
+          expect(foo.all?(n) { |x| x.ok? }).to #{matcher_true}
+          expect(foo.all? { present }).to #{matcher_true}
+          expect(foo.all? { }).to #{matcher_true}
+          expect(foo.all? do; end).to #{matcher_true}
+
+          expect(foo.all? do |x|
+            x + 1
+            x >= 2
+          end).to #{matcher_true}
+        RUBY
+      end
     end
 
     context 'when strict is true' do
       let(:strict) { true }
 
-      include_examples 'explicit common'
-      include_examples 'explicit autocorrect', 'be(true)', 'be(false)'
+      it_behaves_like 'explicit', 'be(true)', 'be(false)'
     end
 
     context 'when strict is false' do
       let(:strict) { false }
 
-      include_examples 'explicit common'
-      include_examples 'explicit autocorrect', 'be_truthy', 'be_falsey'
+      it_behaves_like 'explicit', 'be_truthy', 'be_falsey'
     end
   end
 end
diff --git a/spec/rubocop/cop/rspec/rails/http_status_spec.rb b/spec/rubocop/cop/rspec/rails/http_status_spec.rb
deleted file mode 100644
index 410a69c81..000000000
--- a/spec/rubocop/cop/rspec/rails/http_status_spec.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::Cop::RSpec::Rails::HttpStatus, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when EnforcedStyle is `symbolic`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'symbolic' } }
-
-    it 'registers an offense when using numeric value' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to have_http_status 200 }
-                                             ^^^ Prefer `:ok` over `200` to describe HTTP status code.
-      RUBY
-    end
-
-    it 'does not register an offense when using symbolic value' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status :ok }
-      RUBY
-    end
-
-    it 'does not register an offense when using custom HTTP code' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status 550 }
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status 200 }',
-                     'it { is_expected.to have_http_status :ok }'
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status 404 }',
-                     'it { is_expected.to have_http_status :not_found }'
-
-    context 'with parenthesis' do
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(200) }',
-                       'it { is_expected.to have_http_status(:ok) }'
-
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(404) }',
-                       'it { is_expected.to have_http_status(:not_found) }'
-    end
-  end
-
-  context 'when EnforcedStyle is `numeric`' do
-    let(:cop_config) { { 'EnforcedStyle' => 'numeric' } }
-
-    it 'registers an offense when using symbolic value' do
-      expect_offense(<<-RUBY)
-        it { is_expected.to have_http_status :ok }
-                                             ^^^ Prefer `200` over `:ok` to describe HTTP status code.
-      RUBY
-    end
-
-    it 'does not register an offense when using numeric value' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status 200 }
-      RUBY
-    end
-
-    it 'does not register an offense when using allowed symbols' do
-      expect_no_offenses(<<-RUBY)
-        it { is_expected.to have_http_status :error }
-        it { is_expected.to have_http_status :success }
-        it { is_expected.to have_http_status :missing }
-        it { is_expected.to have_http_status :redirect }
-      RUBY
-    end
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status :ok }',
-                     'it { is_expected.to have_http_status 200 }'
-
-    include_examples 'autocorrect',
-                     'it { is_expected.to have_http_status :not_found }',
-                     'it { is_expected.to have_http_status 404 }'
-
-    context 'with parenthesis' do
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(:ok) }',
-                       'it { is_expected.to have_http_status(200) }'
-
-      include_examples 'autocorrect',
-                       'it { is_expected.to have_http_status(:not_found) }',
-                       'it { is_expected.to have_http_status(404) }'
-    end
-  end
-end
diff --git a/spec/rubocop/cop/rspec/receive_counts_spec.rb b/spec/rubocop/cop/rspec/receive_counts_spec.rb
index 4b25b6531..df4d04a5b 100644
--- a/spec/rubocop/cop/rspec/receive_counts_spec.rb
+++ b/spec/rubocop/cop/rspec/receive_counts_spec.rb
@@ -1,138 +1,131 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ReceiveCounts do
-  subject(:cop) { described_class.new }
-
   it 'flags usage of `exactly(1).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).exactly(1).times
                                   ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).once
     RUBY
   end
 
   it 'flags usage of `exactly(2).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).exactly(2).times
                                   ^^^^^^^^^^^^^^^^^ Use `.twice` instead of `.exactly(2).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).twice
     RUBY
   end
 
   it 'allows `exactly(3).times`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       expect(foo).to receive(:bar).exactly(3).times
     RUBY
   end
 
   it 'allows `exactly(n).times`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       expect(foo).to receive(:bar).exactly(n).times
     RUBY
   end
 
   it 'flags usage of `exactly(1).times` after `with`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).with(baz).exactly(1).times
                                             ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).with(baz).once
     RUBY
   end
 
   it 'flags usage of `exactly(1).times` with return value' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).exactly(1).times.and_return(true)
                                   ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).once.and_return(true)
     RUBY
   end
 
   it 'flags usage of `exactly(1).times` with a block' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).exactly(1).times { true }
                                   ^^^^^^^^^^^^^^^^^ Use `.once` instead of `.exactly(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).once { true }
     RUBY
   end
 
   it 'flags usage of `at_least(1).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).at_least(1).times
                                   ^^^^^^^^^^^^^^^^^^ Use `.at_least(:once)` instead of `.at_least(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).at_least(:once)
     RUBY
   end
 
   it 'flags usage of `at_least(2).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).at_least(2).times
                                   ^^^^^^^^^^^^^^^^^^ Use `.at_least(:twice)` instead of `.at_least(2).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).at_least(:twice)
     RUBY
   end
 
   it 'flags usage of `at_least(2).times` with a block' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).at_least(2).times { true }
                                   ^^^^^^^^^^^^^^^^^^ Use `.at_least(:twice)` instead of `.at_least(2).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).at_least(:twice) { true }
     RUBY
   end
 
   it 'flags usage of `at_most(1).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).at_most(1).times
                                   ^^^^^^^^^^^^^^^^^ Use `.at_most(:once)` instead of `.at_most(1).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).at_most(:once)
     RUBY
   end
 
   it 'flags usage of `at_most(2).times`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).at_most(2).times
                                   ^^^^^^^^^^^^^^^^^ Use `.at_most(:twice)` instead of `.at_most(2).times`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).to receive(:bar).at_most(:twice)
     RUBY
   end
 
   it 'allows exactly(1).times when not called on `receive`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       expect(action).to have_published_event.exactly(1).times
     RUBY
   end
-
-  # Does not auto-correct if not part of the RSpec API
-  include_examples 'autocorrect',
-                   'expect(foo).to have_published_event(:bar).exactly(2).times',
-                   'expect(foo).to have_published_event(:bar).exactly(2).times'
 end
diff --git a/spec/rubocop/cop/rspec/receive_messages_spec.rb b/spec/rubocop/cop/rspec/receive_messages_spec.rb
new file mode 100644
index 000000000..529c5f8ff
--- /dev/null
+++ b/spec/rubocop/cop/rspec/receive_messages_spec.rb
@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::ReceiveMessages, :config do
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(baz)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3, 4].
+        allow(Service).to receive(:bar).and_return(true)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2, 4].
+        allow(Service).to receive(:baz).and_return("foo")
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2, 3].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive_messages(foo: baz, bar: true, baz: "foo")
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and `receive(:foo=)`' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(baz)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+        allow(Service).to receive(:foo=).and_return(true)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive_messages(foo: baz, 'foo=': true)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and symbol methods' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:`).and_return(true)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+        allow(Service).to receive(:[]).and_return(true)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive_messages('`': true, '[]': true)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and return array' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return([1, 2])
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+        allow(Service).to receive(:bar).and_return(3)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive_messages(foo: [1, 2], bar: 3)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and return hash' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return({ a: 1, b: 2 })
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3, 4].
+        allow(Service).to receive(:bar).and_return("baz" => qux)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2, 4].
+        allow(Service).to receive(:baz).and_return(3)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2, 3].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive_messages(foo: { a: 1, b: 2 }, bar: { "baz" => qux }, baz: 3)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and return heredoc' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(<<~SQL)
+          SELECT * FROM users;
+        SQL
+        allow(Service).to receive(:bar).and_return(3)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and receive counts' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(1).once
+        allow(Service).to receive(:bar).and_return(2).twice
+        allow(Service).to receive(:baz).and_return(3).exactly(3).times
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and return with splat' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(*array)
+        allow(Service).to receive(:bar).and_return(*array)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and return multiple' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(1, 2)
+        allow(Service).to receive(:bar).and_return(3, 4)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and message order' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(1).ordered
+        allow(Service).to receive(:bar).and_return(2).ordered
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same local variable' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(user).to receive(:foo).and_return(baz)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+        allow(user).to receive(:bar).and_return(qux)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(user).to receive_messages(foo: baz, bar: qux)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and another methods called between stubs' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(1)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [5].
+        calling_some_method
+        calling_another_method
+        allow(Service).to receive(:bar).and_return(2)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [2].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        calling_some_method
+        calling_another_method
+        allow(Service).to receive_messages(foo: 1, bar: 2)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and initialize return value between stubs' do
+    expect_offense(<<~RUBY)
+      before do
+        foo = Service.new
+        allow(Service).to receive(:foo).and_return(foo)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [5].
+        bar = Service.new
+        allow(Service).to receive(:bar).and_return(bar)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        foo = Service.new
+        bar = Service.new
+        allow(Service).to receive_messages(foo: foo, bar: bar)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and using multiple `.and_return` arguments' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(1, 2)
+        allow(Service).to receive(:bar).and_return(3)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and using `.and_call_original`' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_call_original
+        allow(Service).to receive(:bar).and_return(qux)
+        allow(Service).to receive(:baz).and_call_original
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'different object`' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Foo).to receive(:foo).and_return(baz)
+        allow(Bar).to receive(:bar).and_return(bar)
+        allow(Baz).to receive(:baz).and_return(foo)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and same message`' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Foo).to receive(:foo).and_return(bar)
+        allow(Foo).to receive(:foo).and_return(baz)
+        allow(Foo).to receive(:bar).and_return(qux)
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object with block`' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo) { baz }
+        allow(Service).to receive(:bar) { bar }
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple messeages stubbed on the ' \
+     'same object and `.with` method`' do
+    expect_no_offenses(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).with(1).and_return(baz)
+        allow(Service).to receive(:bar).with(2).and_return(bar)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'same object and different message' do
+    expect_offense(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(bar)
+        allow(Service).to receive(:bar).and_return(qux)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [5].
+        allow(Service).to receive(:foo).and_return(qux)
+        allow(Service).to receive(:baz).and_return(qux)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      before do
+        allow(Service).to receive(:foo).and_return(bar)
+        allow(Service).to receive(:foo).and_return(qux)
+        allow(Service).to receive_messages(bar: qux, baz: qux)
+      end
+    RUBY
+  end
+
+  it 'registers an offense when multiple messeages stubbed on the ' \
+     'different object and same message' do
+    expect_offense(<<~RUBY)
+      RSpec.describe do
+        before do
+          allow(X).to receive(:foo).and_return(1)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [4].
+          allow(X).to receive(:bar).and_return(2)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `receive_messages` instead of multiple stubs on lines [3].
+          allow(Y).to receive(:foo).and_return(3)
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe do
+        before do
+          allow(X).to receive_messages(foo: 1, bar: 2)
+          allow(Y).to receive(:foo).and_return(3)
+        end
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/receive_never_spec.rb b/spec/rubocop/cop/rspec/receive_never_spec.rb
index f56682ceb..4498e4c6e 100644
--- a/spec/rubocop/cop/rspec/receive_never_spec.rb
+++ b/spec/rubocop/cop/rspec/receive_never_spec.rb
@@ -1,54 +1,52 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ReceiveNever do
-  subject(:cop) { described_class.new }
-
   it 'flags usage of `never`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).never
                                    ^^^^^ Use `not_to receive` instead of `never`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).not_to receive(:bar)
     RUBY
   end
 
   it 'flags usage of `never` after `with`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect(foo).to receive(:bar).with(baz).never
                                              ^^^^^ Use `not_to receive` instead of `never`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect(foo).not_to receive(:bar).with(baz)
     RUBY
   end
 
   it 'flags usage of `never` with `is_expected`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       is_expected.to receive(:bar).with(baz).never
                                              ^^^^^ Use `not_to receive` instead of `never`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       is_expected.not_to receive(:bar).with(baz)
     RUBY
   end
 
   it 'flags usage of `never` with `expect_any_instance_of`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       expect_any_instance_of(Foo).to receive(:bar).with(baz).never
                                                              ^^^^^ Use `not_to receive` instead of `never`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       expect_any_instance_of(Foo).not_to receive(:bar).with(baz)
     RUBY
   end
 
   it 'allows method called `never`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       expect(foo).to receive(:bar).with(Value.never)
       expect(foo.never).to eq(bar.never)
       is_expected.to be never
diff --git a/spec/rubocop/cop/rspec/redundant_around_spec.rb b/spec/rubocop/cop/rspec/redundant_around_spec.rb
new file mode 100644
index 000000000..d85dfa734
--- /dev/null
+++ b/spec/rubocop/cop/rspec/redundant_around_spec.rb
@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::RedundantAround, :ruby27 do
+  context 'with another node in `around`' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        around do |example|
+          example.run
+
+          foo
+        end
+      RUBY
+    end
+  end
+
+  context 'with block-surrounded `run` in `around`' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        around do |example|
+          foo { example.run }
+        end
+      RUBY
+    end
+  end
+
+  context 'with another node in numblock `around`' do
+    it 'registers no offense' do
+      expect_no_offenses(<<~RUBY)
+        around do
+          _1.run
+
+          foo
+        end
+      RUBY
+    end
+  end
+
+  context 'with redundant `around`' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        around do |example|
+        ^^^^^^^^^^^^^^^^^^^ Remove redundant `around` hook.
+          example.run
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+
+      RUBY
+    end
+  end
+
+  context 'with redundant block-pass `around`' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        around(&:run)
+        ^^^^^^^^^^^^^ Remove redundant `around` hook.
+      RUBY
+
+      expect_correction(<<~RUBY)
+
+      RUBY
+    end
+  end
+
+  context 'with redundant numblock `around`' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        around do
+        ^^^^^^^^^ Remove redundant `around` hook.
+          _1.run
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+
+      RUBY
+    end
+  end
+
+  context 'with redundant `config.around' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        config.around do |example|
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^ Remove redundant `around` hook.
+          example.run
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+
+      RUBY
+    end
+  end
+
+  context 'with redundant `config.around(:each)' do
+    it 'registers offense' do
+      expect_offense(<<~RUBY)
+        config.around(:each) do |example|
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Remove redundant `around` hook.
+          example.run
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/redundant_predicate_matcher_spec.rb b/spec/rubocop/cop/rspec/redundant_predicate_matcher_spec.rb
new file mode 100644
index 000000000..22c25b919
--- /dev/null
+++ b/spec/rubocop/cop/rspec/redundant_predicate_matcher_spec.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::RedundantPredicateMatcher do
+  it 'registers an offense when using `be_all`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_all be_odd
+                     ^^^^^^^^^^^^^ Use `all` instead of `be_all`.
+      expect(foo).to be_all(expected_foo_element_value)
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `all` instead of `be_all`.
+    RUBY
+
+    expect_no_corrections
+  end
+
+  it 'does not register an offense when using `be_all` with `{}`' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to be_all { |bar| bar == baz }
+    RUBY
+  end
+
+  it 'does not register an offense when using `be_all` with `do ... end`' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to be_all do |bar|
+        bar == baz
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `be_all` without send' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to be_all(false)
+      expect(foo).to be_all(1)
+    RUBY
+  end
+
+  it 'does not register an offense when using `be_match` without argument' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to be_match
+    RUBY
+  end
+
+  it 'registers an offense when using `be_cover`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_cover(bar, baz)
+                     ^^^^^^^^^^^^^^^^^^ Use `cover` instead of `be_cover`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to cover(bar, baz)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_end_with`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_end_with('?')
+                     ^^^^^^^^^^^^^^^^ Use `end_with` instead of `be_end_with`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to end_with('?')
+    RUBY
+  end
+
+  it 'registers an offense when using `be_eql`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_eql(bar)
+                     ^^^^^^^^^^^ Use `eql` instead of `be_eql`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to eql(bar)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_equal`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_equal(bar)
+                     ^^^^^^^^^^^^^ Use `equal` instead of `be_equal`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to equal(bar)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_exist`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_exist("bar.txt")
+                     ^^^^^^^^^^^^^^^^^^^ Use `exist` instead of `be_exist`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to exist("bar.txt")
+    RUBY
+  end
+
+  it 'registers an offense when using `be_exists`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_exists("bar.txt")
+                     ^^^^^^^^^^^^^^^^^^^^ Use `exist` instead of `be_exists`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to exist("bar.txt")
+    RUBY
+  end
+
+  it 'registers an offense when using `be_include`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_include(bar, baz)
+                     ^^^^^^^^^^^^^^^^^^^^ Use `include` instead of `be_include`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to include(bar, baz)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_match`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_match(/bar/)
+                     ^^^^^^^^^^^^^^^ Use `match` instead of `be_match`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to match(/bar/)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_respond_to`' do
+    expect_offense(<<~RUBY)
+      expect("string").to be_respond_to(:length)
+                          ^^^^^^^^^^^^^^^^^^^^^^ Use `respond_to` instead of `be_respond_to`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect("string").to respond_to(:length)
+    RUBY
+  end
+
+  it 'registers an offense when using `be_start_with`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to be_start_with("A")
+                     ^^^^^^^^^^^^^^^^^^ Use `start_with` instead of `be_start_with`.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      expect(foo).to start_with("A")
+    RUBY
+  end
+
+  it 'does not register an offense when using built-in matcher' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to all(bar)
+      expect(foo).to cover(bar)
+      expect(foo).to end_with(bar)
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/remove_const_spec.rb b/spec/rubocop/cop/rspec/remove_const_spec.rb
new file mode 100644
index 000000000..97b4b3c8a
--- /dev/null
+++ b/spec/rubocop/cop/rspec/remove_const_spec.rb
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::RemoveConst do
+  it 'detects the `remove_const` usage' do
+    expect_offense(<<~RUBY)
+      it 'does something' do
+        Object.send(:remove_const, :SomeConstant)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use remove_const in specs. Consider using e.g. `stub_const`.
+      end
+    RUBY
+
+    expect_offense(<<~RUBY)
+      before do
+        SomeClass.send(:remove_const, :SomeConstant)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use remove_const in specs. Consider using e.g. `stub_const`.
+      end
+    RUBY
+  end
+
+  it 'detects the `remove_const` usage when using `__send__`' do
+    expect_offense(<<~RUBY)
+      it 'does something' do
+        NiceClass.__send__(:remove_const, :SomeConstant)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use remove_const in specs. Consider using e.g. `stub_const`.
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/repeated_description_spec.rb b/spec/rubocop/cop/rspec/repeated_description_spec.rb
index 83d8010bd..6c011668a 100644
--- a/spec/rubocop/cop/rspec/repeated_description_spec.rb
+++ b/spec/rubocop/cop/rspec/repeated_description_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::RepeatedDescription do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for repeated descriptions' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         it "does x" do
         ^^^^^^^^^^^ Don't repeat descriptions within an example group.
@@ -18,7 +16,7 @@
   end
 
   it 'registers offense for repeated descriptions separated by a context' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         it "does x" do
         ^^^^^^^^^^^ Don't repeat descriptions within an example group.
@@ -38,7 +36,7 @@
   end
 
   it 'ignores descriptions repeated in a shared context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does x" do
         end
@@ -52,7 +50,7 @@
   end
 
   it 'ignores repeated descriptions in a nested context' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does x" do
         end
@@ -66,7 +64,7 @@
   end
 
   it 'does not flag tests which do not contain description strings' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it { foo }
         it { bar }
@@ -75,7 +73,7 @@
   end
 
   it 'does not flag examples if metadata is different' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it 'do something' do
           # ...
@@ -89,7 +87,7 @@
   end
 
   it 'does not flag examples with same metadata and different description' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it 'do something', :flag do
           # ...
@@ -103,7 +101,7 @@
   end
 
   it 'registers offense for repeated description and metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         it 'do something', :flag do
         ^^^^^^^^^^^^^^^^^^^^^^^^ Don't repeat descriptions within an example group.
@@ -119,7 +117,7 @@
   end
 
   it 'does not flag descriptions with different interpolated variables' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does \#{x}" do
         end
@@ -131,7 +129,7 @@
   end
 
   it 'registers offense for repeated description in same iterator' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         %i[foo bar].each do |type|
           it "does a thing \#{type}" do
@@ -147,7 +145,7 @@
   end
 
   it 'registers offense for repeated description in different iterators' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         %i[foo bar].each do |type|
           it "does a thing \#{type}" do
@@ -165,7 +163,7 @@
   end
 
   it 'does not flag different descriptions in different iterators' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         %i[foo bar].each do |type|
           it "does a thing \#{type}" do
@@ -181,7 +179,7 @@
   end
 
   it 'registers offense if same method used in docstring' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         it(description) do
         ^^^^^^^^^^^^^^^ Don't repeat descriptions within an example group.
@@ -197,7 +195,7 @@
   end
 
   it 'does not flag different methods used as docstring' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it(description) do
           # ...
@@ -209,4 +207,33 @@
       end
     RUBY
   end
+
+  it 'registers an offense when repeated its are used' do
+    expect_offense(<<~RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't repeat descriptions within an example group.
+        its(:x) { is_expected.to be_present }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't repeat descriptions within an example group.
+      end
+    RUBY
+  end
+
+  it 'does not flag examples when different its arguments are used' do
+    expect_no_offenses(<<~RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        its(:y) { is_expected.to be_present }
+      end
+    RUBY
+  end
+
+  it 'does not flag examples when different its block expectations are used' do
+    expect_no_offenses(<<~RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        its(:x) { is_expected.to be_blank }
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/repeated_example_group_body_spec.rb b/spec/rubocop/cop/rspec/repeated_example_group_body_spec.rb
index 749272afc..afabfcb3c 100644
--- a/spec/rubocop/cop/rspec/repeated_example_group_body_spec.rb
+++ b/spec/rubocop/cop/rspec/repeated_example_group_body_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::RepeatedExampleGroupBody do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for repeated describe body' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
       ^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [5]
         it { cool_predicate_method }
@@ -18,7 +16,7 @@
   end
 
   it 'registers an offense for repeated context body' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context 'when awesome case' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated context block body on line(s) [5]
         it { cool_predicate_method }
@@ -32,7 +30,7 @@
   end
 
   it 'registers an offense for several repeated context body' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context 'when usual case' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated context block body on line(s) [5, 9]
         it { cool_predicate_method }
@@ -51,7 +49,7 @@
   end
 
   it 'does not register offense for different block body implementation' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context 'when awesome case' do
         it { cool_predicate_method }
       end
@@ -63,7 +61,7 @@
   end
 
   it 'does not register offense if metadata is different' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it { cool_predicate_method }
       end
@@ -74,8 +72,46 @@
     RUBY
   end
 
+  it 'does not register offense if module arg is different' do
+    expect_no_offenses(<<~RUBY)
+      describe CSV::Row do
+        it { is_expected.to respond_to :headers }
+      end
+
+      describe CSV::Table do
+        it { is_expected.to respond_to :headers }
+      end
+    RUBY
+  end
+
+  it 'does not register offense when module arg namespace is different' do
+    expect_no_offenses(<<~RUBY)
+      describe CSV::Parser do
+        it { expect(described_class).to respond_to(:parse) }
+      end
+
+      describe URI::Parser do
+        it { expect(described_class).to respond_to(:parse) }
+      end
+    RUBY
+  end
+
+  it 'registers an offense for when module arg and namespace are identical' do
+    expect_offense(<<~RUBY)
+      context Net::HTTP do
+      ^^^^^^^^^^^^^^^^^^^^ Repeated context block body on line(s) [5]
+        it { expect(described_class).to respond_to :start }
+      end
+
+      context Net::HTTP do
+      ^^^^^^^^^^^^^^^^^^^^ Repeated context block body on line(s) [1]
+        it { expect(described_class).to respond_to :start }
+      end
+    RUBY
+  end
+
   it 'does not register offense with several docstring' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x', :json, 'request' do
         it { cool_predicate_method }
       end
@@ -87,7 +123,7 @@
   end
 
   it 'registers offense for different groups' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
       ^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [5]
         it { cool_predicate_method }
@@ -101,7 +137,7 @@
   end
 
   it 'does not register offense for example groups in different groups' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'A' do
         describe '.b' do
           context 'when this' do
@@ -116,7 +152,7 @@
   end
 
   it 'registers offense only for RSPEC namespace example groups' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       helpers.describe 'doing x' do
         it { cool_predicate_method }
       end
@@ -134,7 +170,7 @@
   end
 
   it 'registers offense only for RSPEC namespace example groups in any order' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe 'doing x' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [5]
         it { cool_predicate_method }
@@ -152,7 +188,7 @@
   end
 
   it 'registers offense only for example group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe 'A' do
         stub_all_http_calls()
         allowed_statuses = %i[open submitted approved].freeze
@@ -173,7 +209,7 @@
   end
 
   it 'skips `skip` and `pending` statements' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context 'rejected' do
         skip
       end
@@ -188,8 +224,52 @@
     RUBY
   end
 
+  it 'skips `skip` and `pending` statements with arguments' do
+    expect_no_offenses(<<~RUBY)
+      describe '#load' do
+        skip 'storage feature needed'
+      end
+
+      describe '#save' do
+        skip 'storage feature needed'
+      end
+
+      describe '#get_foo' do
+        pending 'foo feature is broken'
+      end
+
+      describe '#set_foo' do
+        pending 'foo feature is broken'
+      end
+    RUBY
+  end
+
+  it 'registers offense correctly if `skip` and `pending` have block' do
+    expect_offense(<<~RUBY)
+      describe '#load' do
+      ^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [5]
+        skip { cool_predicate_method }
+      end
+
+      describe '#save' do
+      ^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [1]
+        skip { cool_predicate_method }
+      end
+
+      describe '#get_foo' do
+      ^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [13]
+        pending { cool_predicate_method }
+      end
+
+      describe '#set_foo' do
+      ^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [9]
+        pending { cool_predicate_method }
+      end
+    RUBY
+  end
+
   it 'registers offense correctly if example groups are separated' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'repeated' do
       ^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block body on line(s) [7]
         it { is_expected.to be_truthy }
@@ -205,7 +285,7 @@
   end
 
   it 'does not register offense for same examples with different data' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context 'when admin' do
         let(:user) { admin }
         it { is_expected.to be_truthy }
@@ -219,7 +299,7 @@
   end
 
   it 'does not register offense if no descriptions, but different body' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context do
         let(:preferences) { default_preferences }
 
@@ -235,7 +315,7 @@
   end
 
   it 'registers offense no descriptions and similar body' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context do
       ^^^^^^^^^^ Repeated context block body on line(s) [7]
         let(:preferences) { %w[a] }
diff --git a/spec/rubocop/cop/rspec/repeated_example_group_description_spec.rb b/spec/rubocop/cop/rspec/repeated_example_group_description_spec.rb
index e96d1b67c..96891b0f7 100644
--- a/spec/rubocop/cop/rspec/repeated_example_group_description_spec.rb
+++ b/spec/rubocop/cop/rspec/repeated_example_group_description_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::RepeatedExampleGroupDescription do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for repeated describe descriptions' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
       ^^^^^^^^^^^^^^^^^^^^^ Repeated describe block description on line(s) [5]
         # example group
@@ -18,7 +16,7 @@
   end
 
   it 'registers an offense for repeated context descriptions' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context 'when awesome case' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated context block description on line(s) [5]
         # example group
@@ -32,7 +30,7 @@
   end
 
   it 'registers an offense with right pointing to lines of code' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'super feature' do
         context 'when some case' do
           # ...
@@ -57,7 +55,7 @@
   end
 
   it 'does not register offense for different block descriptions' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         # example group
       end
@@ -69,7 +67,7 @@
   end
 
   it 'does not register offense for describe block with additional docstring' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe 'Animal', 'dog' do
         # example group
       end
@@ -81,7 +79,7 @@
   end
 
   it 'does not register offense for describe block with several docstring' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       RSpec.describe 'Animal', 'dog', type: :request do
         # example group
       end
@@ -92,8 +90,9 @@
     RUBY
   end
 
-  it 'register offense for different example group with similar descriptions' do
-    expect_offense(<<-RUBY)
+  it 'registers offense for different example group with ' \
+     'similar descriptions' do
+    expect_offense(<<~RUBY)
       describe 'Animal' do
       ^^^^^^^^^^^^^^^^^^^^ Repeated describe block description on line(s) [5]
         # example group
@@ -107,7 +106,7 @@
   end
 
   it 'registers offense only for RSPEC namespace example groups' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       helpers.describe 'doing x' do
         it { cool_predicate_method }
       end
@@ -125,7 +124,7 @@
   end
 
   it 'registers offense only for RSPEC namespace example groups in any order' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe 'doing x' do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block description on line(s) [5]
         it { cool_predicate_method }
@@ -143,7 +142,7 @@
   end
 
   it 'registers offense only for example group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       RSpec.describe 'A' do
         stub_all_http_calls()
         allowed_statuses = %i[open submitted approved].freeze
@@ -163,7 +162,7 @@
   end
 
   it 'considers interpolated docstrings as different descriptions' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context "when class is \#{A::B}" do
         # ...
       end
@@ -175,7 +174,7 @@
   end
 
   it 'registers offense correctly for interpolated docstrings' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       context "when class is \#{A::B}" do
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated context block description on line(s) [5]
         # ...
@@ -189,7 +188,7 @@
   end
 
   it 'considers different classes as different descriptions' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context A::B do
         # ...
       end
@@ -200,8 +199,8 @@
     RUBY
   end
 
-  it 'register offense if same method used in docstring' do
-    expect_offense(<<-RUBY)
+  it 'registers offense if same method used in docstring' do
+    expect_offense(<<~RUBY)
       context(description) do
       ^^^^^^^^^^^^^^^^^^^^^^^ Repeated context block description on line(s) [5]
         # ...
@@ -215,7 +214,7 @@
   end
 
   it 'registers offense correctly if example groups are separated' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'repeated' do
       ^^^^^^^^^^^^^^^^^^^^^^ Repeated describe block description on line(s) [7]
         it { is_expected.to be_truthy }
@@ -231,7 +230,7 @@
   end
 
   it 'does not register offense for example group without descriptions' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       context do
         # ...
       end
diff --git a/spec/rubocop/cop/rspec/repeated_example_spec.rb b/spec/rubocop/cop/rspec/repeated_example_spec.rb
index 879677070..81e9be122 100644
--- a/spec/rubocop/cop/rspec/repeated_example_spec.rb
+++ b/spec/rubocop/cop/rspec/repeated_example_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::RepeatedExample do
-  subject(:cop) { described_class.new }
-
   it 'registers an offense for repeated example' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe 'doing x' do
         it "does x" do
         ^^^^^^^^^^^^^^ Don't repeat examples within an example group.
@@ -19,8 +17,8 @@
     RUBY
   end
 
-  it 'does not register a violation if rspec tag magic is involved' do
-    expect_no_offenses(<<-RUBY)
+  it 'does not register an offense if rspec tag magic is involved' do
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does x" do
           expect(foo).to be(bar)
@@ -34,7 +32,7 @@
   end
 
   it 'does not flag examples with different implementations' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does x" do
           expect(foo).to have_attribute(foo: 1)
@@ -47,8 +45,19 @@
     RUBY
   end
 
+  it 'registers an offense when repeated its are used' do
+    expect_offense(<<~RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't repeat examples within an example group.
+        its(:x) { is_expected.to be_present }
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't repeat examples within an example group.
+      end
+    RUBY
+  end
+
   it 'does not flag examples when different its arguments are used' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         its(:x) { is_expected.to be_present }
         its(:y) { is_expected.to be_present }
@@ -56,8 +65,17 @@
     RUBY
   end
 
+  it 'does not flag examples when different its block expectations are used' do
+    expect_no_offenses(<<~RUBY)
+      describe 'doing x' do
+        its(:x) { is_expected.to be_present }
+        its(:x) { is_expected.to be_blank }
+      end
+    RUBY
+  end
+
   it 'does not flag repeated examples in different scopes' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe 'doing x' do
         it "does x" do
           expect(foo).to be(bar)
diff --git a/spec/rubocop/cop/rspec/repeated_include_example_spec.rb b/spec/rubocop/cop/rspec/repeated_include_example_spec.rb
new file mode 100644
index 000000000..dffe45b01
--- /dev/null
+++ b/spec/rubocop/cop/rspec/repeated_include_example_spec.rb
@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::RepeatedIncludeExample do
+  shared_examples 'detect repeated include examples' do |include_method|
+    context "with include method: #{include_method}" do
+      context 'without parameters' do
+        it "registers an offense for repeated #{include_method}" do
+          expect_offense(<<~RUBY, include_method: include_method)
+            describe 'foo' do
+              %{include_method} 'an x'
+              ^{include_method}^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [4]
+              %{include_method} 'something else'
+              %{include_method} 'an x'
+              ^{include_method}^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2]
+            end
+          RUBY
+
+          expect_no_corrections
+        end
+
+        it "registers an offense for repeated #{include_method} " \
+           'with parentheses' do
+          expect_offense(<<~RUBY, include_method: include_method)
+            describe 'foo' do
+              %{include_method}('an x')
+              ^{include_method}^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [3]
+              %{include_method}('an x')
+              ^{include_method}^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2]
+            end
+          RUBY
+
+          expect_no_corrections
+        end
+
+        it "allows #{include_method} with different names" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'an x'
+              #{include_method} 'a y'
+            end
+          RUBY
+        end
+
+        it "allows repeated #{include_method} in separate example groups" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'an x'
+            end
+
+            describe 'bar' do
+              #{include_method} 'an x'
+            end
+          RUBY
+        end
+      end
+
+      context 'with parameters' do
+        it "registers an offense for repeated #{include_method}" do
+          expect_offense(<<~RUBY, include_method: include_method)
+            describe 'foo' do
+              %{include_method} 'an x', 'y'
+              ^{include_method}^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [4]
+              %{include_method} 'an x', 'other'
+              %{include_method} 'an x', 'y'
+              ^{include_method}^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2]
+            end
+          RUBY
+
+          expect_no_corrections
+        end
+
+        it "registers an offense for repeated #{include_method} " \
+           'with parentheses' do
+          expect_offense(<<~RUBY, include_method: include_method)
+            describe 'foo' do
+              %{include_method}('an x', 'y')
+              ^{include_method}^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [3]
+              %{include_method}('an x', 'y')
+              ^{include_method}^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2]
+            end
+          RUBY
+
+          expect_no_corrections
+        end
+
+        it "registers an offense for repeated #{include_method} " \
+           'with composite literal / const parameters' do
+          expect_offense(<<~RUBY, include_method: include_method)
+            describe 'foo' do
+              %{include_method}('something', [1, 'b', :c, D, { e: :f }, nil])
+              ^{include_method}^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'something' on line(s) [3]
+              %{include_method}('something', [1, 'b', :c, D, { e: :f }, nil])
+              ^{include_method}^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'something' on line(s) [2]
+            end
+          RUBY
+        end
+
+        it "accepts repeated #{include_method} with different parameters" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'an x', 'y'
+              #{include_method} 'an x', 'z'
+              #{include_method} 'an x'
+              #{include_method} 'an x', 'y', 'z'
+            end
+          RUBY
+        end
+
+        it "accepts repeated #{include_method} with different parameters " \
+           'with parentheses' do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method}('an x', 'y')
+              #{include_method}('an x', 'z')
+              #{include_method}('an x')
+              #{include_method}('an x', 'y', 'z')
+            end
+          RUBY
+        end
+
+        it "allows repeated #{include_method} with variable arguments" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'one', foo
+              #{include_method} 'one', foo
+
+              #{include_method} 'two', @foo
+              #{include_method} 'two', @foo
+
+              #{include_method} 'two', @@foo
+              #{include_method} 'two', @@foo
+
+              #{include_method} 'two', $foo
+              #{include_method} 'two', $foo
+            end
+          RUBY
+        end
+
+        it "allows repeated #{include_method} with block" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'one' do
+                'something'
+              end
+              #{include_method} 'one' do
+                'something'
+              end
+
+              #{include_method}('two') { rand }
+              #{include_method}('two') { rand }
+            end
+          RUBY
+        end
+
+        it "allows repeated #{include_method} with passed block" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method}('one', &block)
+              #{include_method}('one', &block)
+
+              #{include_method}('two', &:method)
+              #{include_method}('two', &:method)
+            end
+          RUBY
+        end
+
+        it "allows repeated #{include_method} in separate example groups" do
+          expect_no_offenses(<<~RUBY)
+            describe 'foo' do
+              #{include_method} 'an x', 'y'
+            end
+
+            describe 'bar' do
+              #{include_method} 'an x', 'y'
+            end
+          RUBY
+        end
+      end
+    end
+  end
+
+  it_behaves_like 'detect repeated include examples', 'include_examples'
+  it_behaves_like 'detect repeated include examples', 'it_behaves_like'
+  it_behaves_like 'detect repeated include examples', 'it_should_behave_like'
+
+  context 'with mixed include methods' do
+    it 'registers an offense for repeated includes with no parameters' do
+      expect_offense(<<~RUBY)
+        describe 'foo' do
+          include_examples 'an x'
+          ^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [3, 4]
+          it_behaves_like 'an x'
+          ^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2, 4]
+          it_should_behave_like('an x')
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2, 3]
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'allows includes of different shared_examples' do
+      expect_no_offenses(<<~RUBY)
+        describe 'foo' do
+          include_examples 'one'
+          it_behaves_like 'two'
+          it_should_behave_like 'three'
+        end
+      RUBY
+    end
+
+    it 'registers an offense for repeated includes with same parameters' do
+      expect_offense(<<~RUBY)
+        describe 'foo' do
+          include_examples 'an x', 'y'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [3, 4]
+          it_behaves_like 'an x', 'y'
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2, 4]
+          it_should_behave_like('an x', 'y')
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Repeated include of shared_examples 'an x' on line(s) [2, 3]
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'allows includes with different parameters' do
+      expect_no_offenses(<<~RUBY)
+        describe 'foo' do
+          include_examples 'something', 'x'
+          it_behaves_like 'something', 'y'
+          it_should_behave_like 'something', 42
+        end
+      RUBY
+    end
+
+    it 'allows for beginless ranges', :ruby27 do
+      expect_no_offenses(<<~RUBY)
+        describe 'foo' do
+          include_examples 'irange', ..1
+          it_behaves_like 'irange', ..2
+        end
+      RUBY
+    end
+
+    it 'allows for endless ranges' do
+      expect_no_offenses(<<~RUBY)
+        describe 'foo' do
+          include_examples 'erange', (1..)
+          it_behaves_like 'erange', (2..)
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/repeated_subject_call_spec.rb b/spec/rubocop/cop/rspec/repeated_subject_call_spec.rb
new file mode 100644
index 000000000..7aa697480
--- /dev/null
+++ b/spec/rubocop/cop/rspec/repeated_subject_call_spec.rb
@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::RepeatedSubjectCall do
+  it 'registers an offense when a singular block' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          subject
+          expect { subject }.to not_change { Foo.count }
+          ^^^^^^^^^^^^^^^^^^ Calls to subject are memoized, this block is misleading
+        end
+      end
+    RUBY
+  end
+
+  it 'registers an offense when repeated blocks' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect { subject }.to change { Foo.count }
+          expect { subject }.to not_change { Foo.count }
+          ^^^^^^^^^^^^^^^^^^ Calls to subject are memoized, this block is misleading
+        end
+      end
+    RUBY
+  end
+
+  it 'registers an offense when nested blocks' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect(subject.a).to eq(3)
+          nested_block do
+            expect { on_shard(:europe) { subject } }.to not_change { Foo.count }
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Calls to subject are memoized, this block is misleading
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'registers an offense when custom subjects' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        subject(:bar) { do_something }
+
+        it do
+          bar
+          expect { bar }.to not_change { Foo.count }
+          ^^^^^^^^^^^^^^ Calls to subject are memoized, this block is misleading
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when no block' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect(subject.a).to eq(3)
+          expect(subject.b).to eq(4)
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when block first' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect { subject }.to change { Foo.count }
+          expect(subject.b).to eq(4)
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when different subjects' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        subject { do_something_else }
+        subject(:bar) { do_something }
+
+        it do
+          expect { bar }.to not_change { Foo.count }
+          expect { subject }.to not_change { Foo.count }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple no description it blocks' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect { subject }.to change { Foo.count }
+        end
+
+        it do
+          expect(subject.b).to eq(4)
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when `subject.method_call`' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect { subject.a }.to change { A.count }
+          expect { subject.b }.to not_change { A.count }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when `subject` as an argument' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          expect { create(:bar, baz: subject) }.to change { A.count }
+          expect { create(:bar, subject) }.to not_change { A.count }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when `subject` with not expectation' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        it do
+          allow(Foo).to receive(:bar).and_return(subject)
+          allow(Foo).to receive(:bar) { subject }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when `subject` not inside example' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        subject { do_something }
+
+        it do
+          expect { subject }.to change { Foo.count }
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when `subject` is not inside describe' do
+    expect_no_offenses(<<~RUBY)
+      Foo.subject(:bar)
+      subject(:bar)
+      subject
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/return_from_stub_spec.rb b/spec/rubocop/cop/rspec/return_from_stub_spec.rb
index b9294d770..4b101a305 100644
--- a/spec/rubocop/cop/rspec/return_from_stub_spec.rb
+++ b/spec/rubocop/cop/rspec/return_from_stub_spec.rb
@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::ReturnFromStub, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::ReturnFromStub do
   let(:cop_config) do
     { 'EnforcedStyle' => enforced_style }
   end
@@ -11,14 +9,14 @@
     let(:enforced_style) { 'and_return' }
 
     it 'finds static values returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { 42 }
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(42)
         end
@@ -26,14 +24,14 @@
     end
 
     it 'finds empty values returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) {}
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(nil)
         end
@@ -41,14 +39,14 @@
     end
 
     it 'finds array with only static values returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { [42, 43] }
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return([42, 43])
         end
@@ -56,14 +54,14 @@
     end
 
     it 'finds hash with only static values returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { {a: 42, b: 43} }
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return({a: 42, b: 43})
         end
@@ -71,14 +69,14 @@
     end
 
     it 'finds static values in a block when there are chained methods' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Question).to receive(:meaning).with(:universe) { 42 }
                                                                ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Question).to receive(:meaning).with(:universe).and_return(42)
         end
@@ -86,14 +84,14 @@
     end
 
     it 'finds constants returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { Life::MEANING }
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(Life::MEANING)
         end
@@ -101,14 +99,14 @@
     end
 
     it 'finds nested constants returned from block' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { {Life::MEANING => 42} }
                                       ^ Use `and_return` for static values.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return({Life::MEANING => 42})
         end
@@ -116,7 +114,7 @@
     end
 
     it 'ignores dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { baz }
         end
@@ -124,7 +122,7 @@
     end
 
     it 'ignores variables return from block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           $bar = 42
           baz = 123
@@ -135,7 +133,7 @@
     end
 
     it 'ignores array with dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { [42, baz] }
         end
@@ -143,7 +141,7 @@
     end
 
     it 'ignores hash with dynamic values returned from block' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) { {a: 42, b: baz} }
         end
@@ -151,7 +149,7 @@
     end
 
     it 'ignores block returning string with interpolation' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           bar = 42
           allow(Foo).to receive(:bar) { "You called \#{bar}" }
@@ -159,8 +157,8 @@
       RUBY
     end
 
-    it 'finds concatenated strings with no variables' do
-      expect_offense(<<-RUBY)
+    it 'registers an offense for concatenated strings with no variables' do
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar) do
                                       ^^ Use `and_return` for static values.
@@ -170,7 +168,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return("You called" \
             "me")
@@ -178,16 +176,31 @@
       RUBY
     end
 
-    it 'ignores stubs without return value' do
-      expect_no_offenses(<<-RUBY)
+    it 'registers, but does not try to autocorrect, heredocs' do
+      expect_offense(<<~RUBY)
+        it do
+          allow(Foo).to receive(:bar) do
+                                      ^^ Use `and_return` for static values.
+            <<-TXT
+              You called me
+            TXT
+          end
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'does not register an offense for a stub without return value' do
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar)
         end
       RUBY
     end
 
-    it 'handles stubs in a method' do
-      expect_no_offenses(<<-RUBY)
+    it 'does not register an offense for stub in a method' do
+      expect_no_offenses(<<~RUBY)
         def stub_foo
           allow(Foo).to receive(:bar)
         end
@@ -198,26 +211,51 @@ def stub_foo
   context 'with EnforcedStyle `block`' do
     let(:enforced_style) { 'block' }
 
-    it 'finds static values returned from method' do
-      expect_offense(<<-RUBY)
+    it 'registers an offense for static values returned from method' do
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(42)
                                       ^^^^^^^^^^ Use block for static values.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          allow(Foo).to receive(:bar) { 42 }
+        end
+      RUBY
     end
 
-    it 'finds static values returned from chained method' do
-      expect_offense(<<-RUBY)
+    it 'registers an offense for static values returned from chained method' do
+      expect_offense(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).with(1).and_return(42)
                                               ^^^^^^^^^^ Use block for static values.
         end
       RUBY
+
+      expect_correction(<<~RUBY)
+        it do
+          allow(Foo).to receive(:bar).with(1) { 42 }
+        end
+      RUBY
     end
 
-    it 'ignores dynamic values returned from method' do
-      expect_no_offenses(<<-RUBY)
+    it 'registers, but does not try to autocorrect, heredocs' do
+      expect_offense(<<~RUBY)
+        it do
+          allow(Foo).to receive(:bar).and_return(<<-TXT)
+                                      ^^^^^^^^^^ Use block for static values.
+            You called me
+          TXT
+        end
+      RUBY
+
+      expect_no_corrections
+    end
+
+    it 'does not register an offense for dynamic values returned from method' do
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(baz)
         end
@@ -225,7 +263,7 @@ def stub_foo
     end
 
     it 'ignores string with interpolation returned from method' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           bar = 42
           allow(Foo).to receive(:bar).and_return("You called \#{bar}")
@@ -234,7 +272,7 @@ def stub_foo
     end
 
     it 'ignores multiple values being returned from method' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           allow(Foo).to receive(:bar).and_return(42, 43, 44)
         end
@@ -242,7 +280,7 @@ def stub_foo
     end
 
     it 'finds hash with only static values returned from method' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         allow(Foo).to receive(:bar).and_return({ foo: 42 })
                                     ^^^^^^^^^^ Use block for static values.
         allow(Foo).to receive(:bar).and_return(foo: 42)
@@ -254,7 +292,7 @@ def stub_foo
         )
       RUBY
 
-      expect_correction(<<-RUBY) # Not perfect, but good enough.
+      expect_correction(<<~RUBY) # Not perfect, but good enough.
         allow(Foo).to receive(:bar) { { foo: 42 } }
         allow(Foo).to receive(:bar) { { foo: 42 } }
         allow(Foo).to receive(:bar) { { a: 42,
@@ -263,27 +301,33 @@ def stub_foo
     end
 
     it 'finds nil returned from method' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         allow(Foo).to receive(:bar).and_return(nil)
                                     ^^^^^^^^^^ Use block for static values.
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         allow(Foo).to receive(:bar) { nil }
       RUBY
     end
 
     it 'finds concatenated strings with no variables' do
-      expect_offense(<<-RUBY)
-        allow(Foo).to receive(:bar).and_return('You called ' \\
+      expect_offense(<<~'RUBY')
+        allow(Foo).to receive(:bar).and_return('You called ' \
                                     ^^^^^^^^^^ Use block for static values.
           'me')
       RUBY
 
-      expect_correction(<<-RUBY)
-        allow(Foo).to receive(:bar) { 'You called ' \\
+      expect_correction(<<~'RUBY')
+        allow(Foo).to receive(:bar) { 'You called ' \
           'me' }
       RUBY
     end
+
+    it 'ignores irrelevant #and_return methods' do
+      expect_no_offenses(<<~RUBY)
+        library.visit.and_return(book)
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/scattered_let_spec.rb b/spec/rubocop/cop/rspec/scattered_let_spec.rb
index 09ecb4cf0..2f0a57a23 100644
--- a/spec/rubocop/cop/rspec/scattered_let_spec.rb
+++ b/spec/rubocop/cop/rspec/scattered_let_spec.rb
@@ -1,22 +1,117 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ScatteredLet do
-  subject(:cop) { described_class.new }
+  it 'flags `let` after the first different node' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a }
+        it { expect(subject.foo).to eq(a) }
+        let(:b) { b }
+        ^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
+      end
+    RUBY
 
-  it 'flags `let` after the first different node ' do
-    expect_offense(<<-RUBY)
+    expect_correction(<<~RUBY)
       RSpec.describe User do
         let(:a) { a }
-        subject { User }
         let(:b) { b }
+        it { expect(subject.foo).to eq(a) }
+      end
+    RUBY
+  end
+
+  it 'works with heredocs' do
+    expect_offense(<<~RUBY)
+      describe User do
+        let(:a) { <<-BAR }
+          hello
+          world
+        BAR
+        it { expect(subject.foo).to eq(a) }
+        let(:b) { <<-BAZ }
+        ^^^^^^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
+          again
+        BAZ
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe User do
+        let(:a) { <<-BAR }
+          hello
+          world
+        BAR
+        let(:b) { <<-BAZ }
+          again
+        BAZ
+        it { expect(subject.foo).to eq(a) }
+      end
+    RUBY
+  end
+
+  it 'works with comments' do
+    expect_offense(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a } # a comment
+        # example comment
+        it { expect(subject.foo).to eq(a) }
+        it { expect(subject.fu).to eq(b) } # inline example comment
+        # define the second letter
+        # with a multi-line description
+        let(:b) { b } # inline explanation as well
         ^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.describe User do
+        let(:a) { a } # a comment
+        # define the second letter
+        # with a multi-line description
+        let(:b) { b } # inline explanation as well
+        # example comment
+        it { expect(subject.foo).to eq(a) }
+        it { expect(subject.fu).to eq(b) } # inline example comment
+      end
+    RUBY
+  end
+
+  it 'flags `let` at different nesting levels' do
+    expect_offense(<<~RUBY)
+      describe User do
+        let(:a) { a }
+        it { expect(subject.foo).to eq(a) }
+
+        describe '#property' do
+          let(:c) { c }
+
+          it { expect(subject.property).to eq c }
+
+          let(:d) { d }
+          ^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe User do
+        let(:a) { a }
+        it { expect(subject.foo).to eq(a) }
+
+        describe '#property' do
+          let(:c) { c }
+          let(:d) { d }
+
+          it { expect(subject.property).to eq c }
+
+        end
+      end
+    RUBY
   end
 
   it 'doesnt flag `let!` in the middle of multiple `let`s' do
-    expect_no_offenses(<<-RUBY)
-      RSpec.describe User do
+    expect_no_offenses(<<~RUBY)
+      describe User do
         subject { User }
 
         let(:a) { a }
@@ -25,4 +120,42 @@
       end
     RUBY
   end
+
+  it 'flags scattered `let!`s' do
+    expect_offense(<<~RUBY)
+      describe User do
+        let!(:a) { a }
+        it { expect(subject.foo).to eq(a) }
+        let!(:c) { c }
+        ^^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe User do
+        let!(:a) { a }
+        let!(:c) { c }
+        it { expect(subject.foo).to eq(a) }
+      end
+    RUBY
+  end
+
+  it 'flags `let` with proc argument' do
+    expect_offense(<<~RUBY)
+      describe User do
+        let(:a) { a }
+        it { expect(subject.foo).to eq(a) }
+        let(:user, &args[:build_user])
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Group all let/let! blocks in the example group together.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe User do
+        let(:a) { a }
+        let(:user, &args[:build_user])
+        it { expect(subject.foo).to eq(a) }
+      end
+    RUBY
+  end
 end
diff --git a/spec/rubocop/cop/rspec/scattered_setup_spec.rb b/spec/rubocop/cop/rspec/scattered_setup_spec.rb
index d0ccce9ac..33957dc68 100644
--- a/spec/rubocop/cop/rspec/scattered_setup_spec.rb
+++ b/spec/rubocop/cop/rspec/scattered_setup_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::ScatteredSetup do
-  subject(:cop) { described_class.new }
-
   it 'flags multiple hooks in the same example group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         before { bar }
         ^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 3).
@@ -12,10 +10,17 @@
         ^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 2).
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        before { bar
+      baz  }
+      end
+    RUBY
   end
 
   it 'flags multiple hooks of the same scope with different symbols' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         after { bar }
         ^^^^^^^^^^^^^ Do not define multiple `after` hooks in the same example group (also defined on lines 3, 4).
@@ -25,10 +30,18 @@
         ^^^^^^^^^^^^^^^^^^^^^^^ Do not define multiple `after` hooks in the same example group (also defined on lines 2, 3).
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        after { bar
+      baz#{' '}
+      baz  }
+      end
+    RUBY
   end
 
   it 'flags multiple before(:all) hooks in the same example group' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         before(:all) { bar }
         ^^^^^^^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 3).
@@ -36,10 +49,26 @@
         ^^^^^^^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 2).
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        before(:all) { bar
+      baz  }
+      end
+    RUBY
+  end
+
+  it 'ignores around hooks' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+        around { bar }
+        around { baz }
+      end
+    RUBY
   end
 
   it 'ignores different hooks' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         before { bar }
         after { baz }
@@ -49,7 +78,7 @@
   end
 
   it 'ignores different hook types' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         before { bar }
         before(:all) { baz }
@@ -59,7 +88,7 @@
   end
 
   it 'ignores hooks in different example groups' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         before { bar }
 
@@ -71,7 +100,7 @@
   end
 
   it 'ignores hooks in different shared contexts' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         shared_context 'one' do
           before { bar }
@@ -85,7 +114,7 @@
   end
 
   it 'ignores similar method names inside of examples' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         before { bar }
 
@@ -97,7 +126,7 @@
   end
 
   it 'ignores hooks with different metadata' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       describe Foo do
         before(:example) { foo }
         before(:example, :special_case) { bar }
@@ -106,7 +135,7 @@
   end
 
   it 'flags hooks with similar metadata' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         before(:each, :special_case) { foo }
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on lines 3, 4, 5).
@@ -119,5 +148,58 @@
         before(:example, special_case: false) { bar }
       end
     RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        before(:each, :special_case) { foo
+      bar#{' '}
+      bar#{' '}
+      bar  }
+        before(:example, special_case: false) { bar }
+      end
+    RUBY
+  end
+
+  it 'flags hooks when one of the hooks is an empty block' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        before { do_something }
+        ^^^^^^^^^^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 3).
+        before { }
+        ^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 2).
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        before { do_something
+       }
+      end
+    RUBY
+  end
+
+  it 'flags hooks that contain heredoc arguments and autocorrects correctly' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        before { foo }
+        ^^^^^^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 3).
+        before do
+        ^^^^^^^^^ Do not define multiple `before` hooks in the same example group (also defined on line 2).
+          bar(<<~'TEXT')
+            Hello World!
+          TEXT
+        end
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe Foo do
+        before { foo
+      bar(<<~'TEXT')
+            Hello World!
+          TEXT
+         }
+      end
+    RUBY
   end
 end
diff --git a/spec/rubocop/cop/rspec/shared_context_spec.rb b/spec/rubocop/cop/rspec/shared_context_spec.rb
index 0d13257ea..c21ce0114 100644
--- a/spec/rubocop/cop/rspec/shared_context_spec.rb
+++ b/spec/rubocop/cop/rspec/shared_context_spec.rb
@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::SharedContext do
-  subject(:cop) { described_class.new }
-
   describe 'shared_context' do
     it 'does not register an offense for empty contexts' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_context 'empty' do
         end
       RUBY
     end
 
     it 'registers an offense for shared_context with only examples' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         shared_context 'foo' do
         ^^^^^^^^^^^^^^^^^^^^ Use `shared_examples` when you don't define context.
           it 'performs actions' do
@@ -20,7 +18,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         shared_examples 'foo' do
           it 'performs actions' do
           end
@@ -29,7 +27,7 @@
     end
 
     it 'does not register an offense for `shared_context` with let' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_context 'foo' do
           let(:foo) { :bar }
 
@@ -40,7 +38,7 @@
     end
 
     it 'does not register an offense for `shared_context` with subject' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_context 'foo' do
           subject(:foo) { :bar }
 
@@ -51,7 +49,7 @@
     end
 
     it 'does not register an offense for `shared_context` with before' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_context 'foo' do
           before do
             something
@@ -66,21 +64,21 @@
 
   describe 'shared_examples' do
     it 'does not register an offense for empty examples' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_examples 'empty' do
         end
       RUBY
     end
 
     it 'registers an offense for shared_examples with only let' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         shared_examples 'foo' do
         ^^^^^^^^^^^^^^^^^^^^^ Use `shared_context` when you don't define examples.
           let(:foo) { :bar }
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         shared_context 'foo' do
           let(:foo) { :bar }
         end
@@ -88,14 +86,14 @@
     end
 
     it 'registers an offense for shared_examples with only subject' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         shared_examples 'foo' do
         ^^^^^^^^^^^^^^^^^^^^^ Use `shared_context` when you don't define examples.
           subject(:foo) { :bar }
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         shared_context 'foo' do
           subject(:foo) { :bar }
         end
@@ -103,7 +101,7 @@
     end
 
     it 'registers an offense for shared_examples with only hooks' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         shared_examples 'foo' do
         ^^^^^^^^^^^^^^^^^^^^^ Use `shared_context` when you don't define examples.
           before do
@@ -112,7 +110,7 @@
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         shared_context 'foo' do
           before do
             foo
@@ -122,7 +120,7 @@
     end
 
     it 'does not register an offense for `shared_examples` with it' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         shared_examples 'foo' do
           subject(:foo) { 'foo' }
           let(:bar) { :baz }
diff --git a/spec/rubocop/cop/rspec/shared_examples_spec.rb b/spec/rubocop/cop/rspec/shared_examples_spec.rb
index cc1f46510..87e44d30d 100644
--- a/spec/rubocop/cop/rspec/shared_examples_spec.rb
+++ b/spec/rubocop/cop/rspec/shared_examples_spec.rb
@@ -1,75 +1,167 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::SharedExamples do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense when using symbolic title' do
-    expect_offense(<<-RUBY)
-      it_behaves_like :foo_bar_baz
-                      ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-      it_should_behave_like :foo_bar_baz
+  context 'when using default (string) enforced style' do
+    it 'registers an offense when using symbolic title' do
+      expect_offense(<<~RUBY)
+        it_behaves_like :foo_bar_baz
+                        ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+        it_should_behave_like :foo_bar_baz
+                              ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+        shared_examples :foo_bar_baz
+                        ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+        shared_examples_for :foo_bar_baz
                             ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-      shared_examples :foo_bar_baz
-                      ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-      shared_examples_for :foo_bar_baz
-                          ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-      include_examples :foo_bar_baz
-                       ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-      include_examples :foo_bar_baz, 'foo', 'bar'
-                       ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-
-      shared_examples :foo_bar_baz, 'foo', 'bar' do |param|
-                      ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-        # ...
-      end
+        include_examples :foo_bar_baz
+                         ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+        include_examples :foo_bar_baz, 'foo', 'bar'
+                         ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
 
-      RSpec.shared_examples :foo_bar_baz
-                            ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
-    RUBY
-
-    expect_correction(<<-RUBY)
-      it_behaves_like 'foo bar baz'
-      it_should_behave_like 'foo bar baz'
-      shared_examples 'foo bar baz'
-      shared_examples_for 'foo bar baz'
-      include_examples 'foo bar baz'
-      include_examples 'foo bar baz', 'foo', 'bar'
-
-      shared_examples 'foo bar baz', 'foo', 'bar' do |param|
-        # ...
-      end
+        shared_examples :foo_bar_baz, 'foo', 'bar', :foo_bar, 5 do |param|
+                        ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+          # ...
+        end
+
+        RSpec.shared_examples :foo_bar_baz
+                              ^^^^^^^^^^^^ Prefer 'foo bar baz' over `:foo_bar_baz` to titleize shared examples.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it_behaves_like 'foo bar baz'
+        it_should_behave_like 'foo bar baz'
+        shared_examples 'foo bar baz'
+        shared_examples_for 'foo bar baz'
+        include_examples 'foo bar baz'
+        include_examples 'foo bar baz', 'foo', 'bar'
 
-      RSpec.shared_examples 'foo bar baz'
-    RUBY
+        shared_examples 'foo bar baz', 'foo', 'bar', :foo_bar, 5 do |param|
+          # ...
+        end
+
+        RSpec.shared_examples 'foo bar baz'
+      RUBY
+    end
+
+    it 'does not register an offense when using string title' do
+      expect_no_offenses(<<~RUBY)
+        it_behaves_like 'foo bar baz'
+        it_should_behave_like 'foo bar baz'
+        shared_examples 'foo bar baz'
+        shared_examples_for 'foo bar baz'
+        include_examples 'foo bar baz'
+        include_examples 'foo bar baz', 'foo', 'bar'
+
+        shared_examples 'foo bar baz', 'foo', 'bar' do |param|
+          # ...
+        end
+      RUBY
+    end
+
+    it 'does not register an offense when using Module/Class title' do
+      expect_no_offenses(<<~RUBY)
+        it_behaves_like FooBarBaz
+        it_should_behave_like FooBarBaz
+        shared_examples FooBarBaz
+        shared_examples_for FooBarBaz
+        include_examples FooBarBaz
+        include_examples FooBarBaz, 'foo', 'bar'
+
+        shared_examples FooBarBaz, 'foo', 'bar' do |param|
+          # ...
+        end
+      RUBY
+    end
   end
 
-  it 'does not register an offense when using string title' do
-    expect_no_offenses(<<-RUBY)
-      it_behaves_like 'foo bar baz'
-      it_should_behave_like 'foo bar baz'
-      shared_examples 'foo bar baz'
-      shared_examples_for 'foo bar baz'
-      include_examples 'foo bar baz'
-      include_examples 'foo bar baz', 'foo', 'bar'
-
-      shared_examples 'foo bar baz', 'foo', 'bar' do |param|
-        # ...
+  context 'when using symbol enforced style' do
+    let(:cop_config) { { 'EnforcedStyle' => 'symbol' } }
+
+    it 'registers an offense when using string title' do
+      expect_offense(<<~RUBY)
+        it_behaves_like 'foo bar baz'
+                        ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+        it_should_behave_like 'foo bar baz'
+                              ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+        shared_examples 'foo bar baz'
+                        ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+        shared_examples_for 'foo bar baz'
+                            ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+        include_examples 'foo bar baz'
+                         ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+        include_examples 'Foo Bar Baz'
+                         ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"Foo Bar Baz"` to symbolize shared examples.
+        include_examples 'foo bar baz', 'foo', 'bar'
+                         ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+
+        shared_examples 'foo bar baz', 'foo', 'bar' do |param|
+                        ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+          # ...
+        end
+
+        RSpec.shared_examples 'foo bar baz'
+                              ^^^^^^^^^^^^^ Prefer :foo_bar_baz over `"foo bar baz"` to symbolize shared examples.
+      RUBY
+
+      expect_correction(<<~RUBY)
+        it_behaves_like :foo_bar_baz
+        it_should_behave_like :foo_bar_baz
+        shared_examples :foo_bar_baz
+        shared_examples_for :foo_bar_baz
+        include_examples :foo_bar_baz
+        include_examples :foo_bar_baz
+        include_examples :foo_bar_baz, 'foo', 'bar'
+
+        shared_examples :foo_bar_baz, 'foo', 'bar' do |param|
+          # ...
+        end
+
+        RSpec.shared_examples :foo_bar_baz
+      RUBY
+    end
+
+    it 'does not register an offense when using symbol' do
+      expect_no_offenses(<<~RUBY)
+        it_behaves_like :foo_bar_baz
+        it_should_behave_like :foo_bar_baz
+        shared_examples :foo_bar_baz
+        shared_examples_for :foo_bar_baz
+        include_examples :foo_bar_baz
+        include_examples :foo_bar_baz, :foo, :bar
+
+        shared_examples :foo_bar_baz, 'foo', 'bar', 'foo bar', 5 do |param|
+          # ...
+        end
+
+        RSpec.shared_examples :foo_bar_baz
+      RUBY
+    end
+
+    it 'does not register an offense when using Module/Class title' do
+      expect_no_offenses(<<~RUBY)
+        it_behaves_like FooBarBaz
+        it_should_behave_like FooBarBaz
+        shared_examples FooBarBaz
+        shared_examples_for FooBarBaz
+        include_examples FooBarBaz
+        include_examples FooBarBaz, 'foo', 'bar'
+
+        shared_examples FooBarBaz, 'foo', 'bar', 'foo bar', 5 do |param|
+          # ...
+        end
+      RUBY
+    end
+
+    context 'when using run_test!' do
+      before do
+        other_cops.dig('RSpec', 'Language', 'Includes', 'Examples')
+          .push('run_test!')
       end
-    RUBY
-  end
 
-  it 'does not register an offense when using Module/Class title' do
-    expect_no_offenses(<<-RUBY)
-      it_behaves_like FooBarBaz
-      it_should_behave_like FooBarBaz
-      shared_examples FooBarBaz
-      shared_examples_for FooBarBaz
-      include_examples FooBarBaz
-      include_examples FooBarBaz, 'foo', 'bar'
-
-      shared_examples FooBarBaz, 'foo', 'bar' do |param|
-        # ...
+      it 'does not occur an error' do
+        expect_no_offenses(<<~RUBY)
+          run_test!
+        RUBY
       end
-    RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/single_argument_message_chain_spec.rb b/spec/rubocop/cop/rspec/single_argument_message_chain_spec.rb
index 7839214c8..8e49d668e 100644
--- a/spec/rubocop/cop/rspec/single_argument_message_chain_spec.rb
+++ b/spec/rubocop/cop/rspec/single_argument_message_chain_spec.rb
@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::SingleArgumentMessageChain do
-  subject(:cop) { described_class.new }
-
   describe 'receive_message_chain' do
     it 'reports single-argument calls' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before do
           allow(foo).to receive_message_chain(:one) { :two }
                         ^^^^^^^^^^^^^^^^^^^^^ Use `receive` instead of calling `receive_message_chain` with a single argument.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         before do
           allow(foo).to receive(:one) { :two }
         end
@@ -20,7 +18,7 @@
     end
 
     it 'accepts multi-argument calls' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           allow(foo).to receive_message_chain(:one, :two) { :three }
         end
@@ -28,14 +26,14 @@
     end
 
     it 'reports single-argument string calls' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before do
           allow(foo).to receive_message_chain("one") { :two }
                         ^^^^^^^^^^^^^^^^^^^^^ Use `receive` instead of calling `receive_message_chain` with a single argument.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         before do
           allow(foo).to receive("one") { :two }
         end
@@ -43,7 +41,7 @@
     end
 
     it 'accepts multi-argument string calls' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           allow(foo).to receive_message_chain("one.two") { :three }
         end
@@ -51,7 +49,7 @@
     end
 
     it 'accepts single-argument calls with variable' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           foo = %i[:one :two]
           allow(foo).to receive_message_chain(foo) { :many }
@@ -60,7 +58,7 @@
     end
 
     it 'accepts single-argument calls with send node' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           allow(foo).to receive_message_chain(foo) { :many }
         end
@@ -69,14 +67,14 @@
 
     context 'with single-element array argument' do
       it 'reports an offense' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           before do
             allow(foo).to receive_message_chain([:one]) { :two }
                           ^^^^^^^^^^^^^^^^^^^^^ Use `receive` instead of calling `receive_message_chain` with a single argument.
           end
         RUBY
 
-        expect_correction(<<-RUBY)
+        expect_correction(<<~RUBY)
           before do
             allow(foo).to receive(:one) { :two }
           end
@@ -86,7 +84,7 @@
 
     context 'with multiple-element array argument' do
       it "doesn't report an offense" do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           before do
             allow(foo).to receive_message_chain([:one, :two]) { :many }
           end
@@ -96,7 +94,7 @@
 
     context 'with single-key hash argument' do
       it 'reports an offense' do
-        expect_offense(<<-RUBY)
+        expect_offense(<<~RUBY)
           before do
             allow(foo).to receive_message_chain(bar: 42)
                           ^^^^^^^^^^^^^^^^^^^^^ Use `receive` instead of calling `receive_message_chain` with a single argument.
@@ -107,7 +105,7 @@
           end
         RUBY
 
-        expect_correction(<<-RUBY)
+        expect_correction(<<~RUBY)
           before do
             allow(foo).to receive(:bar).and_return(42)
             allow(foo).to receive("bar").and_return(42)
@@ -119,7 +117,7 @@
 
     context 'with multiple keys hash argument' do
       it "doesn't report an offense" do
-        expect_no_offenses(<<-RUBY)
+        expect_no_offenses(<<~RUBY)
           before do
             allow(foo).to receive_message_chain(bar: 42, baz: 42)
           end
@@ -130,14 +128,14 @@
 
   describe 'stub_chain' do
     it 'reports single-argument calls' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before do
           foo.stub_chain(:one) { :two }
               ^^^^^^^^^^ Use `stub` instead of calling `stub_chain` with a single argument.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         before do
           foo.stub(:one) { :two }
         end
@@ -145,7 +143,7 @@
     end
 
     it 'accepts multi-argument calls' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           foo.stub_chain(:one, :two) { :three }
         end
@@ -153,14 +151,14 @@
     end
 
     it 'reports single-argument string calls' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         before do
           foo.stub_chain("one") { :two }
               ^^^^^^^^^^ Use `stub` instead of calling `stub_chain` with a single argument.
         end
       RUBY
 
-      expect_correction(<<-RUBY)
+      expect_correction(<<~RUBY)
         before do
           foo.stub("one") { :two }
         end
@@ -168,7 +166,7 @@
     end
 
     it 'accepts multi-argument string calls' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         before do
           foo.stub_chain("one.two") { :three }
         end
diff --git a/spec/rubocop/cop/rspec/skip_block_inside_example_spec.rb b/spec/rubocop/cop/rspec/skip_block_inside_example_spec.rb
new file mode 100644
index 000000000..1126eb84e
--- /dev/null
+++ b/spec/rubocop/cop/rspec/skip_block_inside_example_spec.rb
@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SkipBlockInsideExample do
+  it 'registers an offense when using `skip` with a block' do
+    expect_offense(<<~RUBY)
+      it 'does something' do
+        skip 'not yet implemented' do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't pass a block to `skip` inside examples.
+        end
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `skip` with a numblock', :ruby27 do
+    expect_offense(<<~RUBY)
+      it 'does something' do
+        skip 'not yet implemented' do
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Don't pass a block to `skip` inside examples.
+          _1
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `skip` without a block' do
+    expect_no_offenses(<<~RUBY)
+      it 'does something' do
+        skip 'not yet implemented'
+      end
+    RUBY
+  end
+
+  it 'does not register an offense outside examples' do
+    expect_no_offenses(<<~RUBY)
+      skip 'not yet implemented' do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `pending`' do
+    # RSpec would through an ArgumentError
+    expect_no_offenses(<<~RUBY)
+      it 'does something' do
+        pending 'not yet implemented' do
+          # ...
+        end
+        foo 'dfdf' do
+          # ...
+        end
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/sort_metadata_spec.rb b/spec/rubocop/cop/rspec/sort_metadata_spec.rb
new file mode 100644
index 000000000..9b8c3c66a
--- /dev/null
+++ b/spec/rubocop/cop/rspec/sort_metadata_spec.rb
@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SortMetadata do
+  it 'does not register an offense when using only symbol metadata ' \
+     'in alphabetical order' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Something', :a, :b do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using only symbol metadata, ' \
+     'but not in alphabetical order' do
+    expect_offense(<<~RUBY)
+      describe 'Something', :b, :a do
+                            ^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'Something', :a, :b do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense for a symbol metadata before a non-symbol ' \
+     'argument' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Something', :z, :a, variable, foo: :bar do
+      end
+    RUBY
+  end
+
+  it 'registers an offense only for trailing symbol metadata not in ' \
+     'alphabetical order' do
+    expect_offense(<<~RUBY)
+      describe 'Something', :z, :a, variable, :c, :b do
+                                              ^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'Something', :z, :a, variable, :b, :c do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when a symbol metadata not in alphabetical order ' \
+     'is before a variable argument being the last argument ' \
+     'as it could be a hash' do
+    expect_offense(<<~RUBY)
+      describe 'Something', :z, :a, some_hash do
+                            ^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'Something', :a, :z, some_hash do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using a second level description ' \
+     'not in alphabetical order with symbol metadata' do
+    expect_no_offenses(<<~RUBY)
+      describe 'Something', 'second docstring', :a, :b do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using a second level description ' \
+     'and metadata not in alphabetical order' do
+    expect_offense(<<~RUBY)
+      describe 'Something', 'second docstring', :b, :a do
+                                                ^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'Something', 'second docstring', :a, :b do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using only a hash of metadata ' \
+     'with keys in alphabetical order' do
+    expect_no_offenses(<<~RUBY)
+      context 'Something', baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using only a hash of metadata, ' \
+     'but with keys not in alphabetical order' do
+    expect_offense(<<~RUBY)
+      context 'Something', foo: 'bar', baz: true do
+                           ^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      context 'Something', baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using mixed metadata ' \
+     'in alphabetical order (respectively)' do
+    expect_no_offenses(<<~RUBY)
+      it 'Something', :a, :b, baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using mixed metadata, ' \
+     'but only the hash keys are in alphabetical order' do
+    expect_offense(<<~RUBY)
+      it 'Something', :b, :a, baz: true, foo: 'bar' do
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'Something', :a, :b, baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using mixed metadata, ' \
+     'but only the symbol keys are in alphabetical order' do
+    expect_offense(<<~RUBY)
+      it 'Something', :a, :b, foo: 'bar', baz: true do
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'Something', :a, :b, baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using mixed metadata ' \
+     'and both symbols metadata and hash keys are not in alphabetical order' do
+    expect_offense(<<~RUBY)
+      it 'Something', :b, :a, foo: 'bar', baz: true do
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'Something', :a, :b, baz: true, foo: 'bar' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using mixed metadata ' \
+     'and both symbols metadata and hash keys are not in alphabetical order ' \
+     'and the hash values are complex objects' do
+    expect_offense(<<~RUBY)
+      it 'Something', variable, 'B', :a, key => {}, foo: ->(x) { bar(x) }, Identifier.sample => true, baz: Snafu.new do
+                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      it 'Something', variable, 'B', :a, baz: Snafu.new, foo: ->(x) { bar(x) }, Identifier.sample => true, key => {} do
+      end
+    RUBY
+  end
+
+  it 'registers an offense only when example or group has a block' do
+    expect_offense(<<~RUBY)
+      shared_examples 'a difficult situation', 'B', :z, :a do |x, y|
+                                                    ^^^^^^ Sort metadata alphabetically.
+      end
+
+      include_examples 'a difficult situation', 'value', 'another value'
+    RUBY
+
+    expect_correction(<<~RUBY)
+      shared_examples 'a difficult situation', 'B', :a, :z do |x, y|
+      end
+
+      include_examples 'a difficult situation', 'value', 'another value'
+    RUBY
+  end
+
+  it 'registers an offense also when the metadata is not on one single line' do
+    expect_offense(<<~RUBY)
+      describe 'Something', :foo, :bar,
+                            ^^^^^^^^^^^ Sort metadata alphabetically.
+                                   baz: 'goo' do
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      describe 'Something', :bar, :foo, baz: 'goo' do
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using only symbol metadata ' \
+     'in a config block, but not in alphabetical order' do
+    expect_offense(<<~RUBY)
+      RSpec.configure do |c|
+        c.before(:each, :b, :a) { freeze_time }
+                        ^^^^^^ Sort metadata alphabetically.
+        c.after(:each, foo: 'bar', baz: true) { travel_back }
+                       ^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      RSpec.configure do |c|
+        c.before(:each, :a, :b) { freeze_time }
+        c.after(:each, baz: true, foo: 'bar') { travel_back }
+      end
+    RUBY
+  end
+
+  it "ignores includes' positional arguments" do
+    expect_no_offenses(<<~RUBY)
+      include_examples 'z', 'a' do
+      end
+      it_behaves_like 'z', 'a' do
+      end
+      include_context 'z', 'a' do
+      end
+    RUBY
+  end
+
+  context 'when using custom RSpec language ' \
+          'without adjusting the RuboCop RSpec language configuration' do
+    it 'does not register an offense' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describan "Algo", :b, :a do
+          contexto_compartido 'una situación complicada', foo: 'bar', baz: true do
+          end
+
+          ejemplo "hablando español", foo: 'bar', baz: true do
+          end
+        end
+      RUBY
+    end
+  end
+
+  context 'when using custom RSpec language ' \
+          'and adjusting the RuboCop RSpec language configuration' do
+    before do
+      other_cops.tap do |config|
+        config.dig('RSpec', 'Language', 'ExampleGroups', 'Regular').push(
+          'describan', 'contexto_compartido'
+        )
+        config.dig('RSpec', 'Language', 'Examples', 'Regular').push('ejemplo')
+      end
+    end
+
+    it 'registers an offense' do
+      expect_offense(<<~RUBY)
+        RSpec.describan "Algo", :b, :a do
+                                ^^^^^^ Sort metadata alphabetically.
+          contexto_compartido 'una situación complicada', foo: 'bar', baz: true do
+                                                          ^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+          end
+
+          ejemplo "hablando español", foo: 'bar', baz: true do
+                                      ^^^^^^^^^^^^^^^^^^^^^ Sort metadata alphabetically.
+          end
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describan "Algo", :a, :b do
+          contexto_compartido 'una situación complicada', baz: true, foo: 'bar' do
+          end
+
+          ejemplo "hablando español", baz: true, foo: 'bar' do
+          end
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/spec_file_path_format_spec.rb b/spec/rubocop/cop/rspec/spec_file_path_format_spec.rb
new file mode 100644
index 000000000..92a36e78f
--- /dev/null
+++ b/spec/rubocop/cop/rspec/spec_file_path_format_spec.rb
@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SpecFilePathFormat, :config do
+  it 'registers an offense when wrong path for describe' do
+    expect_offense(<<~RUBY, 'wrong_path_foo_spec.rb')
+      describe MyClass, 'foo' do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong path for all kinds of example group' do
+    expect_offense(<<~RUBY, 'wrong_path_foo_spec.rb')
+      example_group MyClass, 'foo' do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong class but a correct method' do
+    expect_offense(<<~RUBY, 'wrong_class_foo_spec.rb')
+      describe MyClass, '#foo' do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong class and highlights metadata' do
+    expect_offense(<<~RUBY, 'wrong_class_foo_spec.rb')
+      describe MyClass, '#foo', blah: :blah do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*foo*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong class name' do
+    expect_offense(<<~RUBY, 'wrong_class_spec.rb')
+      describe MyClass do; end
+      ^^^^^^^^^^^^^^^^ Spec path should end with `my_class*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong top-level class name' do
+    expect_offense(<<~RUBY, 'wrong_class_spec.rb')
+      describe ::MyClass do; end
+      ^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when wrong class name with a symbol argument' do
+    expect_offense(<<~RUBY, 'wrong_class_spec.rb')
+      describe MyClass, :foo do; end
+      ^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when second argument contains spaces' do
+    expect_offense(<<~RUBY, 'wrong_class_spec.rb')
+      describe MyClass, "via `local_failures`" do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*via_local_failures*_spec.rb`.
+    RUBY
+  end
+
+  it 'does not register an offense when only shared examples' do
+    expect_no_offenses(<<~RUBY, 'spec/models/user.rb')
+      shared_examples_for 'foo' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when example groups do not describe ' \
+     'a class/method' do
+    expect_no_offenses(<<~RUBY, 'some/class/spec.rb')
+      describe 'Test something' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when multiple top level describes' do
+    expect_no_offenses(<<~RUBY, 'some/class/spec.rb')
+      describe MyClass, 'do_this' do; end
+      describe MyClass, 'do_that' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when class specs' do
+    expect_no_offenses(<<~RUBY, 'some/class_spec.rb')
+      describe Some::Class do; end
+    RUBY
+  end
+
+  it 'does not register an offense when different parent directories' do
+    expect_no_offenses(<<~RUBY, 'parent_dir/some/class_spec.rb')
+      describe Some::Class do; end
+    RUBY
+  end
+
+  it 'does not register an offense when CamelCaps class names' do
+    expect_no_offenses(<<~RUBY, 'my_class_spec.rb')
+      describe MyClass do; end
+    RUBY
+  end
+
+  it 'does not register an offense when ACRONYMClassNames' do
+    expect_no_offenses(<<~RUBY, 'abc_one/two_spec.rb')
+      describe ABCOne::Two do; end
+    RUBY
+  end
+
+  it 'does not register an offense when ALLCAPS class names' do
+    expect_no_offenses(<<~RUBY, 'allcaps_spec.rb')
+      describe ALLCAPS do; end
+    RUBY
+  end
+
+  it 'does not register an offense when alphanumeric class names' do
+    expect_no_offenses(<<~RUBY, 'ipv4_and_ipv6_spec.rb')
+      describe IPV4AndIPV6 do; end
+    RUBY
+  end
+
+  it 'does not register an offense when instance methods' do
+    expect_no_offenses(<<~RUBY, 'some/class/inst_spec.rb')
+      describe Some::Class, '#inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when class methods' do
+    expect_no_offenses(<<~RUBY, 'some/class/inst_spec.rb')
+      describe Some::Class, '.inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when flat hierarchies for ' \
+     'instance methods' do
+    expect_no_offenses(<<~RUBY, 'some/class_inst_spec.rb')
+      describe Some::Class, '#inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when flat hierarchies for class methods' do
+    expect_no_offenses(<<~RUBY, 'some/class_inst_spec.rb')
+      describe Some::Class, '.inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when subdirs for instance methods' do
+    filename = 'some/class/instance_methods/inst_spec.rb'
+    expect_no_offenses(<<~RUBY, filename)
+      describe Some::Class, '#inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when subdirs for class methods' do
+    filename = 'some/class/class_methods/inst_spec.rb'
+    expect_no_offenses(<<~RUBY, filename)
+      describe Some::Class, '.inst' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when non-alphanumeric characters' do
+    expect_no_offenses(<<~RUBY, 'some/class/pred_spec.rb')
+      describe Some::Class, '#pred?' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when bang method' do
+    expect_no_offenses(<<~RUBY, 'some/class/bang_spec.rb')
+      describe Some::Class, '#bang!' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when an arbitrary spec suffix' do
+    filename = 'some/class/thing_predicate_spec.rb'
+    expect_no_offenses(<<~RUBY, filename)
+      describe Some::Class, '#thing?' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when an arbitrary spec name for ' \
+     'an operator method' do
+    filename = 'my_little_class/spaceship_operator_spec.rb'
+    expect_no_offenses(<<~RUBY, filename)
+      describe MyLittleClass, '#<=>' do; end
+    RUBY
+  end
+
+  it 'registers an offense when path containing the class name' do
+    filename = '/home/foo/spec/models/bar_spec.rb'
+    expect_offense(<<~RUBY, filename)
+      describe Foo do; end
+      ^^^^^^^^^^^^ Spec path should end with `foo*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when path with incorrect collapsed namespace' do
+    filename = '/home/foo/spec/very/my_class_spec.rb'
+    expect_offense(<<~RUBY, filename)
+      describe Very::Long::Namespace::MyClass do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `very/long/namespace/my_class*_spec.rb`.
+    RUBY
+  end
+
+  it 'registers an offense when path with incorrect expanded namespace' do
+    filename = '/home/foo/spec/very/long/my_class_spec.rb'
+    expect_offense(<<~RUBY, filename)
+      module Very
+        module Medium
+          describe MyClass do; end
+          ^^^^^^^^^^^^^^^^ Spec path should end with `very/medium/my_class*_spec.rb`.
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register offense when absolute file path' do
+    # RuboCop's Commissioner is calling it, too
+    allow(File).to receive(:expand_path).and_call_original
+    allow(File).to receive(:expand_path).with('my_class_spec.rb').and_return(
+      '/home/foo/spec/very/long/namespace/my_class_spec.rb'
+    )
+    expect_no_offenses(<<~RUBY, 'my_class_spec.rb')
+      describe Very::Long::Namespace::MyClass do; end
+    RUBY
+  end
+
+  # RSpec/SpecFilePathFormat runs on all files - not only **/*_spec.rb
+  it 'does not register an offense when files defining an empty class' do
+    expect_no_offenses(<<~RUBY)
+      class Foo
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when path is under spec/routing and ' \
+     'it ends with _spec.rb' do
+    expect_no_offenses(<<~RUBY, 'spec/routing/foo_spec.rb')
+      describe 'routes to the foo controller' do; end
+    RUBY
+  end
+
+  it 'does not register an offense when `type: :routing` is used and ' \
+     'it ends with _spec.rb' do
+    expect_no_offenses(<<~RUBY, 'spec/foo_spec.rb')
+      describe 'routes to the foo controller', type: :routing do; end
+    RUBY
+  end
+
+  context 'when configured with `CustomTransform: { "FooFoo" => "foofoo" }`' do
+    let(:cop_config) { { 'CustomTransform' => { 'FooFoo' => 'foofoo' } } }
+
+    it 'does not register an offense for custom module name transformation' do
+      expect_no_offenses(<<~RUBY, 'foofoo/some/class/bar_spec.rb')
+        describe FooFoo::Some::Class, '#bar' do; end
+      RUBY
+    end
+  end
+
+  context 'when configured with `IgnoreMethods: false`' do
+    let(:cop_config) { { 'IgnoreMethods' => false } }
+    let(:suffix) { 'my_class*look_here_a_method*_spec.rb' }
+
+    it 'registers an offense when file path not include method name' do
+      expect_offense(<<~RUBY, 'my_class_spec.rb')
+        describe MyClass, '#look_here_a_method' do; end
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Spec path should end with `my_class*look_here_a_method*_spec.rb`.
+      RUBY
+    end
+  end
+
+  context 'when configured with `IgnoreMethods: true`' do
+    let(:cop_config) { { 'IgnoreMethods' => true } }
+
+    it 'does not register an offense when file path not include method name' do
+      expect_no_offenses(<<~RUBY, 'my_class_spec.rb')
+        describe MyClass, '#look_here_a_method' do; end
+      RUBY
+    end
+  end
+
+  context 'when configured with `IgnoreMetadata: { "foo" => "bar" }`' do
+    let(:cop_config) { { 'IgnoreMetadata' => { 'foo' => 'bar' } } }
+
+    it 'does not register an offense when include ignored metadata' do
+      expect_no_offenses(<<~RUBY, 'wrong_class_spec.rb')
+        describe MyClass, foo: :bar do; end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/spec_file_path_suffix_spec.rb b/spec/rubocop/cop/rspec/spec_file_path_suffix_spec.rb
new file mode 100644
index 000000000..02964d2b1
--- /dev/null
+++ b/spec/rubocop/cop/rspec/spec_file_path_suffix_spec.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SpecFilePathSuffix do
+  let(:message) { 'Spec path should end with `_spec.rb`.' }
+
+  it 'registers an offense for a repeated .rb' do
+    expect_global_offense(<<~RUBY, 'my_class/foo_spec.rb.rb', message)
+      describe MyClass, '#foo' do; end
+    RUBY
+  end
+
+  it 'registers an offense for a file missing a .rb' do
+    expect_global_offense(<<~RUBY, 'my_class/foo_specorb', message)
+      describe MyClass, '#foo' do; end
+    RUBY
+  end
+
+  it 'registers an offense for a file missing _spec' do
+    expect_global_offense(<<~RUBY, 'spec/models/user.rb', message)
+      describe User, '#foo' do; end
+    RUBY
+  end
+
+  it 'registers an offense for a feature file missing _spec' do
+    expect_global_offense(<<~RUBY, 'spec/features/my_feature.rb', message)
+      feature "my feature" do; end
+    RUBY
+  end
+
+  it 'registers an offense for a file without the .rb extension' do
+    expect_global_offense(<<~RUBY, 'spec/models/user_specxrb', message)
+      describe User do; end
+    RUBY
+  end
+
+  it 'does not register an offense for shared examples' do
+    expect_no_global_offenses(<<~RUBY, 'spec/models/user.rb')
+      shared_examples_for 'foo' do; end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/stubbed_mock_spec.rb b/spec/rubocop/cop/rspec/stubbed_mock_spec.rb
new file mode 100644
index 000000000..1c920b638
--- /dev/null
+++ b/spec/rubocop/cop/rspec/stubbed_mock_spec.rb
@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::StubbedMock do
+  it 'flags stubbed message expectation' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive(:bar).and_return('hello world')
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags stubbed message expectation with a block' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive(:bar) { 'hello world' }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'ignores stubbed message expectation with a block and block parameter' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to receive(:bar) { |x| bar }
+    RUBY
+  end
+
+  it 'flags stubbed message expectation with argument matching' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive(:bar).with(42).and_return('hello world')
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags stubbed message expectation with argument matching and a block' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive(:bar).with(42) { 'hello world' }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'ignores `have_received`' do
+    expect_no_offenses(<<~RUBY)
+      expect(foo).to have_received(:bar)
+    RUBY
+  end
+
+  it 'flags `receive_messages`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive_messages(foo: 42, bar: 777)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags `receive_message_chain`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive_message_chain(:foo, bar: 777)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags `receive_message_chain` with `.and_return`' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive_message_chain(:foo, :bar).and_return(777)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags `receive_message_chain` with a block' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive_message_chain(:foo, :bar) { 777 }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags with order and count constraints', pending: 'Not implemented yet' do
+    expect_offense(<<~RUBY)
+      expect(foo).to receive(:bar) { 'hello world' }.ordered
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar).ordered { 'hello world' }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar).with(42).ordered { 'hello world' }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar).once.with(42).ordered { 'hello world' }
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar) { 'hello world' }.once.with(42).ordered
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar).once.with(42).and_return('hello world').ordered
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags block-pass' do
+    expect_offense(<<~RUBY)
+      canned = -> { 42 }
+      expect(foo).to receive(:bar, &canned)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive(:bar).with(42, &canned)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+      expect(foo).to receive_message_chain(:foo, :bar, &canned)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+    RUBY
+  end
+
+  it 'flags `is_expected`' do
+    expect_offense(<<~RUBY)
+      is_expected.to receive(:bar).and_return(:baz)
+      ^^^^^^^^^^^ Prefer `allow(subject)` over `is_expected` when configuring a response.
+    RUBY
+  end
+
+  it 'flags `expect_any_instance_of`' do
+    expect_offense(<<~RUBY)
+      expect_any_instance_of(Foo).to receive(:bar).and_return(:baz)
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `allow_any_instance_of` over `expect_any_instance_of` when configuring a response.
+    RUBY
+  end
+
+  it 'ignores message allowances' do
+    expect_no_offenses(<<~RUBY)
+      allow(foo).to receive(:bar).and_return('hello world')
+      allow(foo).to receive(:bar) { 'hello world' }
+      allow(foo).to receive(:bar).with(42).and_return('hello world')
+      allow(foo).to receive(:bar).with(42) { 'hello world' }
+      allow(foo).to receive_messages(foo: 42, bar: 777)
+      allow(foo).to receive_message_chain(:foo, bar: 777)
+      allow(foo).to receive_message_chain(:foo, :bar).and_return(777)
+      allow(foo).to receive_message_chain(:foo, :bar) { 777 }
+      allow(foo).to receive(:bar, &canned)
+    RUBY
+  end
+
+  it 'flags even when passed arguments without parentheses' do
+    expect_offense(<<~RUBY)
+      expect(Foo)
+      ^^^^^^^^^^^ Prefer `allow` over `expect` when configuring a response.
+        .to receive(:new)
+        .with(bar).and_return baz
+    RUBY
+  end
+
+  it 'flags `are_expected`' do
+    expect_offense(<<~RUBY)
+      are_expected.to receive(:bar).and_return(:baz)
+      ^^^^^^^^^^^^ Prefer an allow statement over `are_expected` when configuring a response.
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/subject_declaration_spec.rb b/spec/rubocop/cop/rspec/subject_declaration_spec.rb
new file mode 100644
index 000000000..e9292c5a9
--- /dev/null
+++ b/spec/rubocop/cop/rspec/subject_declaration_spec.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::SubjectDeclaration do
+  shared_examples 'flag unclear subject declaration' do |subject|
+    context "when #{subject.inspect} is declared" do
+      context 'with `let!` helper' do
+        it 'is an offense without a block pass' do
+          expect_offense(<<~RUBY, subject: subject.inspect)
+            let!(%{subject}) { 'some subject' }
+            ^^^^^^{subject}^ Use subject explicitly rather than using let
+          RUBY
+        end
+
+        it 'is an offense with a block pass' do
+          expect_offense(<<~RUBY, subject: subject.inspect)
+            let!(%{subject}, &block)
+            ^^^^^^{subject}^^^^^^^^^ Use subject explicitly rather than using let
+          RUBY
+        end
+      end
+
+      context 'with `let` helper' do
+        it 'is an offense without a block pass' do
+          expect_offense(<<~RUBY, subject: subject.inspect)
+            let(%{subject}) { 'some subject' }
+            ^^^^^{subject}^ Use subject explicitly rather than using let
+          RUBY
+        end
+
+        it 'is an offense with a block pass' do
+          expect_offense(<<~RUBY, subject: subject.inspect)
+            let(%{subject}, &block)
+            ^^^^^{subject}^^^^^^^^^ Use subject explicitly rather than using let
+          RUBY
+        end
+      end
+
+      it 'is an offense when declared redundantly with `subject`' do
+        expect_offense(<<~RUBY, subject: subject.inspect)
+          subject(%{subject}) { 'some subject' }
+          ^^^^^^^^^{subject}^ Ambiguous declaration of subject
+        RUBY
+      end
+
+      it 'is an offense when declared redundantly with `subject!`' do
+        expect_offense(<<~RUBY, subject: subject.inspect)
+          subject!(%{subject}) { 'some subject' }
+          ^^^^^^^^^^{subject}^ Ambiguous declaration of subject
+        RUBY
+      end
+    end
+  end
+
+  it_behaves_like 'flag unclear subject declaration', :subject
+  it_behaves_like 'flag unclear subject declaration', 'subject'
+  it_behaves_like 'flag unclear subject declaration', :subject!
+  it_behaves_like 'flag unclear subject declaration', 'subject!'
+
+  context 'when subject helper is used directly' do
+    it 'does not register an offense on named subject' do
+      expect_no_offenses(<<~RUBY)
+        subject(:foo) { 'bar' }
+      RUBY
+    end
+
+    it 'does not register an offense on named `subject!`' do
+      expect_no_offenses(<<~RUBY)
+        subject!(:foo) { 'bar' }
+      RUBY
+    end
+
+    it 'does not register an offense on subject with no name' do
+      expect_no_offenses(<<~RUBY)
+        subject { 'some subject' }
+      RUBY
+    end
+  end
+
+  context 'when subject is not declared' do
+    it 'does not register an offense when `let` is used' do
+      expect_no_offenses(<<~RUBY)
+        let(:foo) { 'bar' }
+      RUBY
+    end
+
+    it 'does not register an offense when `let!` is used' do
+      expect_no_offenses(<<~RUBY)
+        let!(:foo) { 'bar' }
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/subject_stub_spec.rb b/spec/rubocop/cop/rspec/subject_stub_spec.rb
index 09f2c0fc4..575f27f76 100644
--- a/spec/rubocop/cop/rspec/subject_stub_spec.rb
+++ b/spec/rubocop/cop/rspec/subject_stub_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::SubjectStub do
-  subject(:cop) { described_class.new }
-
   it 'flags when subject is stubbed' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -20,8 +18,28 @@
     RUBY
   end
 
+  it 'flags when subject is stubbed and there are several named subjects ' \
+     'in the same example group' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        subject(:foo) { described_class.new }
+        subject(:bar) { described_class.new }
+        subject(:baz) { described_class.new }
+
+        before do
+          allow(bar).to receive(:bar).and_return(baz)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+
+        it 'uses expect twice' do
+          expect(foo.bar).to eq(baz)
+        end
+      end
+    RUBY
+  end
+
   it 'flags when subject is mocked' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -44,7 +62,7 @@
   end
 
   it 'flags when an unnamed subject is mocked' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject { described_class.new }
 
@@ -56,8 +74,47 @@
     RUBY
   end
 
+  it 'flags when a forced subject! is mocked and called as subject' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        subject!(:foo) { described_class.new }
+
+        it 'uses bang subject!' do
+          expect(subject).to receive(:bar)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+      end
+    RUBY
+  end
+
+  it 'flags when a forced subject! is mocked and called by name' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        subject!(:foo) { described_class.new }
+
+        it 'uses bang subject! by name' do
+          expect(foo).to receive(:bar)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+      end
+    RUBY
+  end
+
+  it 'flags when an unnamed forced subject! is mocked' do
+    expect_offense(<<~RUBY)
+      describe Foo do
+        subject! { described_class.new }
+
+        it 'uses bang subject!' do
+          expect(subject).to receive(:bar)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+      end
+    RUBY
+  end
+
   it 'flags an expectation made on an unnamed subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -69,8 +126,8 @@
     RUBY
   end
 
-  it 'flags one-line expectcation syntax' do
-    expect_offense(<<-RUBY)
+  it 'flags one-line expectation syntax' do
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -82,8 +139,8 @@
     RUBY
   end
 
-  it 'ignores stub within context where subject name changed' do
-    expect_no_offenses(<<-RUBY)
+  it 'flags stub within context where subject name changed' do
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -92,6 +149,7 @@
 
           it 'tries to trick rubocop-rspec' do
             allow(foo).to receive(:baz)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
           end
         end
       end
@@ -99,7 +157,7 @@
   end
 
   it 'flags stub inside all matcher' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { [Object.new] }
         it 'tries to trick rubocop-rspec' do
@@ -111,7 +169,7 @@
   end
 
   it 'flags nested subject stubs when nested subject uses same name' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -131,8 +189,8 @@
     RUBY
   end
 
-  it 'ignores nested stubs when nested subject is anonymous' do
-    expect_no_offenses(<<-RUBY)
+  it 'flags nested stubs when nested subject is anonymous' do
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -141,6 +199,7 @@
 
           before do
             allow(foo).to receive(:wow)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
           end
 
           it 'tries to trick rubocop-rspec' do
@@ -152,7 +211,7 @@
   end
 
   it 'flags nested subject stubs when example group does not define subject' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -171,7 +230,7 @@
   end
 
   it 'flags nested subject stubs' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -180,6 +239,7 @@
 
           before do
             allow(foo).to receive(:wow)
+            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
             allow(bar).to receive(:wow)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
           end
@@ -193,7 +253,7 @@
   end
 
   it 'flags nested subject stubs when adjacent context redefines' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -210,7 +270,7 @@
   end
 
   it 'flags deeply nested subject stubs' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -222,7 +282,9 @@
 
             before do
               allow(foo).to receive(:wow)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
               allow(bar).to receive(:wow)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
               allow(baz).to receive(:wow)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
             end
@@ -233,7 +295,7 @@
   end
 
   it 'flags negated runners' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -249,7 +311,7 @@
   end
 
   it 'flags multiple-method stubs' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -263,7 +325,7 @@
   end
 
   it 'flags chain stubs' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -277,7 +339,7 @@
   end
 
   it 'flags spy subject stubs' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         subject(:foo) { described_class.new }
 
@@ -292,7 +354,7 @@
   end
 
   it 'flags when an implicit subject is mocked' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       describe Foo do
         it 'uses an implicit subject' do
           expect(subject).to receive(:bar).and_return(baz)
@@ -301,4 +363,94 @@
       end
     RUBY
   end
+
+  it 'flags when there are several top level example groups' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Foo do
+        subject(:foo) { described_class.new }
+
+        specify do
+          expect(foo).to eq(foo)
+        end
+      end
+
+      RSpec.describe Bar do
+        subject(:bar) { described_class.new }
+
+        specify do
+          allow(bar).to receive(:bar)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+      end
+    RUBY
+  end
+
+  it 'flags stubs inside helper methods' do
+    expect_offense(<<~RUBY)
+      RSpec.describe Bar do
+        subject(:bar) { described_class.new }
+
+        def allow_subject_to_receive_bar
+          allow(bar).to receive(:bar)
+          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores subjects from sibling example groups' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        describe '#bar' do
+          subject(:bar) { :bar }
+          it { }
+        end
+
+        describe '#baz' do
+          specify do
+            allow(bar).to receive(:bar)
+          end
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores subjects from parent example groups redefined with let' do
+    expect_no_offenses(<<~RUBY)
+      RSpec.describe Foo do
+        subject(:foo) { described_class.new }
+
+        context '#bar' do
+          subject(:bar) { foo.bar }
+
+          let(:foo) { described_class.new }
+
+          before do
+            allow(foo).to receive(:active?).and_return(true)
+          end
+        end
+      end
+    RUBY
+  end
+
+  describe 'top level example groups' do
+    %i[
+      describe xdescribe fdescribe
+      context xcontext fcontext
+      feature xfeature ffeature
+      example_group
+      shared_examples shared_examples_for shared_context
+    ].each do |method|
+      it "flags in top level #{method}" do
+        expect_offense(<<~RUBY)
+          RSpec.#{method} '#{method}' do
+            it 'uses an implicit subject' do
+              expect(subject).to receive(:bar)
+              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not stub methods of the object under test.
+            end
+          end
+        RUBY
+      end
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/undescriptive_literals_description_spec.rb b/spec/rubocop/cop/rspec/undescriptive_literals_description_spec.rb
new file mode 100644
index 000000000..2114be22f
--- /dev/null
+++ b/spec/rubocop/cop/rspec/undescriptive_literals_description_spec.rb
@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::UndescriptiveLiteralsDescription, :config do
+  it 'registers an offense when using `describe` with only execute string' do
+    expect_offense(<<~RUBY)
+      describe `time` do
+               ^^^^^^ Description should be descriptive.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `context` with only execute string' do
+    expect_offense(<<~RUBY)
+      context `time` do
+              ^^^^^^ Description should be descriptive.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `it` with only execute string' do
+    expect_offense(<<~RUBY)
+      it `time` do
+         ^^^^^^ Description should be descriptive.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `describe` with only regex' do
+    expect_offense(<<~RUBY)
+      describe /time/ do
+               ^^^^^^ Description should be descriptive.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when using `describe` with only Integer' do
+    expect_offense(<<~RUBY)
+      describe 10000 do
+               ^^^^^ Description should be descriptive.
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with method call' do
+    expect_no_offenses(<<~RUBY)
+      describe foo.to_s do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with local variable' do
+    expect_no_offenses(<<~RUBY)
+      types.each do |type|
+        describe type do
+        end
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with ' \
+     'instance variable' do
+    expect_no_offenses(<<~RUBY)
+      describe @foo do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with ' \
+     'grobal variable' do
+    expect_no_offenses(<<~RUBY)
+      describe $foo do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with a string' do
+    expect_no_offenses(<<~RUBY)
+      describe '#foo' do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with a class' do
+    expect_no_offenses(<<~RUBY)
+      describe Foo do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `context` with a string' do
+    expect_no_offenses(<<~RUBY)
+      context 'when foo is bar' do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `it` with a string' do
+    expect_no_offenses(<<~RUBY)
+      it 'does something' do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with an ' \
+     'interpolation string' do
+    expect_no_offenses(<<~RUBY)
+      describe "foo \#{bar}" do
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with a ' \
+     'heredoc string' do
+    expect_no_offenses(<<~RUBY)
+      describe <<~DESC do
+        foo
+      DESC
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when using `describe` with a ' \
+     'string concatenation' do
+    expect_no_offenses(<<~RUBY)
+      describe 'foo' + `time` do
+        context 'when ' + 1.to_s do
+          it 'returns ' + /something/.to_s do
+          end
+        end
+      end
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/unspecified_exception_spec.rb b/spec/rubocop/cop/rspec/unspecified_exception_spec.rb
index 46b2e99b2..8269209f8 100644
--- a/spec/rubocop/cop/rspec/unspecified_exception_spec.rb
+++ b/spec/rubocop/cop/rspec/unspecified_exception_spec.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::UnspecifiedException do
-  subject(:cop) { described_class.new }
-
   context 'with raise_error matcher' do
     it 'detects the `unspecified_exception` offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect {
           raise StandardError
         }.to raise_error
@@ -14,7 +12,7 @@
     end
 
     it 'allows empty exception specification when not expecting an error' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError
         }.not_to raise_error
@@ -22,7 +20,7 @@
     end
 
     it 'allows exception classes' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError
         }.to raise_error(StandardError)
@@ -30,7 +28,7 @@
     end
 
     it 'allows exception messages' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error('error')
@@ -38,7 +36,7 @@
     end
 
     it 'allows exception types with messages' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error(StandardError, 'error')
@@ -46,7 +44,7 @@
     end
 
     it 'allows exception matching regular expressions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error(/err/)
@@ -54,7 +52,7 @@
     end
 
     it 'allows exception types with matching regular expressions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error(StandardError, /err/)
@@ -62,7 +60,7 @@
     end
 
     it 'allows classes with blocks with braces' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error { |err| err.data }
@@ -70,7 +68,7 @@
     end
 
     it 'allows classes with blocks with do/end' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_error do |error|
@@ -80,18 +78,42 @@
     end
 
     it 'allows parameterized exceptions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         my_exception = StandardError.new('my exception')
         expect {
           raise my_exception
         }.to raise_error(my_exception)
       RUBY
     end
+
+    it 'allows a subject function to be named raise_error' do
+      expect_no_offenses(<<~RUBY)
+        def raise_exception
+          raise StandardError
+        end
+
+        expect {
+          raise_error
+        }.to raise_error(StandardError)
+      RUBY
+    end
+
+    it 'allows a subject function to be named raise_exception' do
+      expect_no_offenses(<<~RUBY)
+        def raise_exception
+          raise StandardError
+        end
+
+        expect {
+          raise_exception
+        }.to raise_error(StandardError)
+      RUBY
+    end
   end
 
   context 'with raise_exception matcher' do
     it 'detects the `unspecified_exception` offense' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         expect {
           raise StandardError
         }.to raise_exception
@@ -100,7 +122,7 @@
     end
 
     it 'allows empty exception specification when not expecting an error' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError
         }.not_to raise_exception
@@ -108,7 +130,7 @@
     end
 
     it 'allows exception classes' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError
         }.to raise_exception(StandardError)
@@ -116,7 +138,7 @@
     end
 
     it 'allows exception messages' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception('error')
@@ -124,7 +146,7 @@
     end
 
     it 'allows exception types with messages' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception(StandardError, 'error')
@@ -132,7 +154,7 @@
     end
 
     it 'allows exception matching regular expressions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception(/err/)
@@ -140,7 +162,7 @@
     end
 
     it 'allows exception types with matching regular expressions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception(StandardError, /err/)
@@ -148,7 +170,7 @@
     end
 
     it 'allows classes with blocks with braces' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception { |err| err.data }
@@ -156,7 +178,7 @@
     end
 
     it 'allows classes with blocks with do/end' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         expect {
           raise StandardError.new('error')
         }.to raise_exception do |error|
@@ -166,12 +188,78 @@
     end
 
     it 'allows parameterized exceptions' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         my_exception = StandardError.new('my exception')
         expect {
           raise my_exception
         }.to raise_exception(my_exception)
       RUBY
     end
+
+    it 'detects chained offenses' do
+      expect_offense(<<~RUBY)
+        expect {
+          foo
+        }.to raise_exception.and change { bar }
+             ^^^^^^^^^^^^^^^ Specify the exception being captured
+      RUBY
+    end
+
+    it 'detects more chained offenses' do
+      expect_offense(<<~RUBY)
+        expect {
+          foo
+        }.to raise_exception.and change { bar }.and change { baz }
+             ^^^^^^^^^^^^^^^ Specify the exception being captured
+      RUBY
+    end
+
+    it 'detects more complex chained offenses' do
+      expect_offense(<<~RUBY)
+        expect {
+          foo
+        }.to change { bar }.and raise_exception.and change { baz }
+                                ^^^^^^^^^^^^^^^ Specify the exception being captured
+      RUBY
+    end
+
+    it 'does not confuse blocks with chains' do
+      expect_no_offenses(<<~RUBY)
+        expect do
+          expect { foo }.not_to raise_error
+        end.to change(Foo, :count).by(3)
+      RUBY
+    end
+
+    it 'allows a subject function to be named raise_exception' do
+      expect_no_offenses(<<~RUBY)
+        def raise_error
+          raise StandardError
+        end
+
+        expect {
+          raise_exception
+        }.to raise_exception(StandardError)
+      RUBY
+    end
+
+    it 'allows a subject function to be named raise_error' do
+      expect_no_offenses(<<~RUBY)
+        def raise_error
+          raise StandardError
+        end
+
+        expect {
+          raise_error
+        }.to raise_exception(StandardError)
+      RUBY
+    end
+
+    it 'detects even when a non-send node is an ancestor' do
+      expect_offense(<<~RUBY)
+        expect { raise 'error' }.to (branch_conditional ? raise_error : handle_exception)
+                                                          ^^^^^^^^^^^ Specify the exception being captured
+      RUBY
+    end
   end
 end
diff --git a/spec/rubocop/cop/rspec/variable_definition_spec.rb b/spec/rubocop/cop/rspec/variable_definition_spec.rb
new file mode 100644
index 000000000..948fe5140
--- /dev/null
+++ b/spec/rubocop/cop/rspec/variable_definition_spec.rb
@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::VariableDefinition do
+  context 'when EnforcedStyle is `symbols`' do
+    let(:cop_config) { { 'EnforcedStyle' => 'symbols' } }
+
+    it 'registers an offense for string name' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          let('user_name') { 'Adam' }
+              ^^^^^^^^^^^ Use symbols for variable names.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe Foo do
+          let(:user_name) { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense for interpolated string' do
+      expect_no_offenses(<<~'RUBY')
+        RSpec.describe Foo do
+          let("user-#{id}") { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense for multiline string' do
+      expect_no_offenses(<<~'RUBY')
+        RSpec.describe Foo do
+          let("user" \
+              "-foo") { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense for symbol names' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          let(:user_name) { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense when not inside spec group' do
+      expect_no_offenses(<<~RUBY)
+        let('user_name') { 'Adam' }
+      RUBY
+    end
+  end
+
+  context 'when EnforcedStyle is `strings`' do
+    let(:cop_config) { { 'EnforcedStyle' => 'strings' } }
+
+    it 'registers an offense for symbol name' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          let(:user_name) { 'Adam' }
+              ^^^^^^^^^^ Use strings for variable names.
+        end
+      RUBY
+
+      expect_correction(<<~RUBY)
+        RSpec.describe Foo do
+          let("user_name") { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'registers an offense for interpolated symbol' do
+      expect_offense(<<~'RUBY')
+        RSpec.describe Foo do
+          let(:"user-#{id}") { 'Adam' }
+              ^^^^^^^^^^^^^ Use strings for variable names.
+        end
+      RUBY
+
+      expect_correction(<<~'RUBY')
+        RSpec.describe Foo do
+          let("user-#{id}") { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense for string names' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          let('user_name') { 'Adam' }
+        end
+      RUBY
+    end
+
+    it 'does not register offense when not inside spec group' do
+      expect_no_offenses(<<~RUBY)
+        let(:user_name) { 'Adam' }
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/variable_name_spec.rb b/spec/rubocop/cop/rspec/variable_name_spec.rb
new file mode 100644
index 000000000..863b3e8f1
--- /dev/null
+++ b/spec/rubocop/cop/rspec/variable_name_spec.rb
@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::VariableName do
+  context 'when configured for `snake_case`' do
+    let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
+
+    context 'when `let` with symbol names' do
+      it 'registers an offense for camelCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:userName) { 'Adam' }
+                ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'registers an offense for PascalCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:UserName) { 'Adam' }
+                ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'registers offense with multiple lets' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:userName) { 'Adam' }
+                ^^^^^^^^^ Use snake_case for variable names.
+            let(:user_email) { 'adam@example.com' }
+            let(:userAge) { 20 }
+                ^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register an offense for snake_case' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            let(:user_name) { 'Adam' }
+          end
+        RUBY
+      end
+
+      it 'does not register offense for interpolated symbol' do
+        expect_no_offenses(<<~'RUBY')
+          RSpec.describe Foo do
+            let(:"user#{name}") { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` with string names' do
+      it 'registers an offense for camelCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let('userName') { 'Adam' }
+                ^^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'registers an offense for kebab-case' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let('user-name') { 'Adam' }
+                ^^^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register an offense for snake_case' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            let('user_name') { 'Adam' }
+          end
+        RUBY
+      end
+
+      it 'does not register offense for interpolated string' do
+        expect_no_offenses(<<~'RUBY')
+          RSpec.describe Foo do
+            let("user#{name}") { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` with proc' do
+      it 'registers offense' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:userName, &create_user)
+                ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let!`' do
+      it 'registers an offense for camelCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let!(:userName) { 'Adam' }
+                 ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for snake_case' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            let!(:user_name) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `subject`' do
+      it 'registers an offense for camelCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            subject(:userName) { 'Adam' }
+                    ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for snake_case' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            subject(:user_name) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `subject!`' do
+      it 'registers an offense for camelCase' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            subject!(:userName) { 'Adam' }
+                     ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for snake_case' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            subject!(:user_name) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` inside spec group' do
+      it 'registers an offense when describe' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:userName) { 'Adam' }
+                ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+
+      it 'registers an offense when shared_examples' do
+        expect_offense(<<~RUBY)
+          RSpec.shared_examples 'foo example' do
+            let(:userName) { 'Adam' }
+                ^^^^^^^^^ Use snake_case for variable names.
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` not inside spec group' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          let(:userName) { 'Adam' }
+        RUBY
+      end
+    end
+  end
+
+  context 'when configured for `camelCase`' do
+    let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
+
+    context 'when `let`' do
+      it 'registers an offense for snake_case' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:user_name) { 'Adam' }
+                ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for camelCase' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            let(:userName) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let!`' do
+      it 'registers an offense for snake_case' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let!(:user_name) { 'Adam' }
+                 ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for camelCase' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            let!(:userName) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `subject`' do
+      it 'registers an offense for snake_case' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            subject(:user_name) { 'Adam' }
+                    ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for camelCase' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            subject(:userName) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `subject!`' do
+      it 'registers an offense for snake_case' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            subject!(:user_name) { 'Adam' }
+                     ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+
+      it 'does not register offense for camelCase' do
+        expect_no_offenses(<<~RUBY)
+          RSpec.describe Foo do
+            subject!(:userName) { 'Adam' }
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` inside spec group' do
+      it 'registers an offense when describe' do
+        expect_offense(<<~RUBY)
+          RSpec.describe Foo do
+            let(:user_name) { 'Adam' }
+                ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+
+      it 'registers an offense when shared_examples' do
+        expect_offense(<<~RUBY)
+          RSpec.shared_examples 'foo example' do
+            let(:user_name) { 'Adam' }
+                ^^^^^^^^^^ Use camelCase for variable names.
+          end
+        RUBY
+      end
+    end
+
+    context 'when `let` not inside spec group' do
+      it 'does not register an offense' do
+        expect_no_offenses(<<~RUBY)
+          let(:user_name) { 'Adam' }
+        RUBY
+      end
+    end
+  end
+
+  context 'when configured to ignore certain patterns (deprecated key)' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'snake_case',
+        'IgnoredPatterns' => ['^userFood$', '^userPet$'] }
+    end
+
+    it 'registers an offense when not matching any ignored patterns' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          let(:userName) { 'Adam' }
+              ^^^^^^^^^ Use snake_case for variable names.
+        end
+      RUBY
+    end
+
+    it 'does not register an offense when matching any ignored pattern' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          let(:userFood) { 'Adam' }
+        end
+      RUBY
+    end
+  end
+
+  context 'when configured to allow certain patterns' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'snake_case',
+        'AllowedPatterns' => ['^userFood$', '^userPet$'] }
+    end
+
+    it 'registers an offense when not matching any allowed patterns' do
+      expect_offense(<<~RUBY)
+        RSpec.describe Foo do
+          let(:userName) { 'Adam' }
+              ^^^^^^^^^ Use snake_case for variable names.
+        end
+      RUBY
+    end
+
+    it 'does not register an offense when matching any allowed pattern' do
+      expect_no_offenses(<<~RUBY)
+        RSpec.describe Foo do
+          let(:userFood) { 'Adam' }
+        end
+      RUBY
+    end
+  end
+end
diff --git a/spec/rubocop/cop/rspec/verified_double_reference_spec.rb b/spec/rubocop/cop/rspec/verified_double_reference_spec.rb
new file mode 100644
index 000000000..a040b03f0
--- /dev/null
+++ b/spec/rubocop/cop/rspec/verified_double_reference_spec.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::VerifiedDoubleReference do
+  verified_doubles = %w[
+    class_double
+    class_spy
+    instance_double
+    instance_spy
+    mock_model
+    object_double
+    object_spy
+    stub_model
+  ]
+
+  verified_doubles.each do |verified_double|
+    describe verified_double do
+      context 'with requirement to use constant class references' do
+        it 'does not flag an offense when using a constant reference' do
+          expect_no_offenses("#{verified_double}(ClassName)")
+        end
+
+        it 'flags an offense when using a string reference' do
+          expect_offense(<<~RUBY, verified_double: verified_double)
+            %{verified_double}('ClassName')
+            _{verified_double} ^^^^^^^^^^^ Use a constant class reference for verified doubles. String references are not verifying unless the class is loaded.
+            %{verified_double}('Foo::Bar::Baz')
+            _{verified_double} ^^^^^^^^^^^^^^^ Use a constant class reference for verified doubles. String references are not verifying unless the class is loaded.
+            %{verified_double}('::Foo::Bar')
+            _{verified_double} ^^^^^^^^^^^^ Use a constant class reference for verified doubles. String references are not verifying unless the class is loaded.
+          RUBY
+
+          expect_correction(<<~RUBY)
+            #{verified_double}(ClassName)
+            #{verified_double}(Foo::Bar::Baz)
+            #{verified_double}(::Foo::Bar)
+          RUBY
+        end
+      end
+    end
+  end
+
+  it 'does not flag an offense when reference is not a supported style' do
+    expect_no_offenses(<<~RUBY)
+      klass = Array
+      instance_double(klass)
+
+      @sut = Array
+      let(:double) { instance_double(@sut) }
+
+      object_double([])
+
+      class_double(:Model)
+    RUBY
+  end
+end
diff --git a/spec/rubocop/cop/rspec/verified_doubles_spec.rb b/spec/rubocop/cop/rspec/verified_doubles_spec.rb
index 42eb802d6..27e7cb549 100644
--- a/spec/rubocop/cop/rspec/verified_doubles_spec.rb
+++ b/spec/rubocop/cop/rspec/verified_doubles_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::Cop::RSpec::VerifiedDoubles, :config do
-  subject(:cop) { described_class.new(config) }
-
+RSpec.describe RuboCop::Cop::RSpec::VerifiedDoubles do
   it 'finds a `double` instead of an `instance_double`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it do
         foo = double("Widget")
               ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
@@ -16,7 +14,7 @@
     let(:cop_config) { {} }
 
     it 'find doubles whose name is a symbol' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           foo = double(:widget)
                 ^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
@@ -25,7 +23,7 @@
     end
 
     it 'finds a `spy` instead of an `instance_spy`' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           foo = spy("Widget")
                 ^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
@@ -38,7 +36,7 @@
     let(:cop_config) { { 'IgnoreSymbolicNames' => true } }
 
     it 'ignores doubles whose name is a symbol' do
-      expect_no_offenses(<<-RUBY)
+      expect_no_offenses(<<~RUBY)
         it do
           foo = double(:widget)
         end
@@ -46,7 +44,7 @@
     end
 
     it 'still flags doubles whose name is a string' do
-      expect_offense(<<-RUBY)
+      expect_offense(<<~RUBY)
         it do
           foo = double("widget")
                 ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
@@ -55,29 +53,29 @@
     end
   end
 
-  it 'doubles that have no name specified' do
-    expect_offense(<<-RUBY)
-      it do
-        foo = double
-              ^^^^^^ Prefer using verifying doubles over normal doubles.
-      end
-    RUBY
-  end
-
-  context 'when configured to ignore nameless doubles' do
-    let(:cop_config) { { 'IgnoreNameless' => true } }
+  context 'when configured not to ignore nameless doubles' do
+    let(:cop_config) { { 'IgnoreNameless' => false } }
 
-    it 'ignores doubles that have no name specified' do
-      expect_no_offenses(<<-RUBY)
+    it 'flags doubles that have no name specified' do
+      expect_offense(<<~RUBY)
         it do
           foo = double
+                ^^^^^^ Prefer using verifying doubles over normal doubles.
         end
       RUBY
     end
   end
 
+  it 'ignores doubles that have no name specified' do
+    expect_no_offenses(<<~RUBY)
+      it do
+        foo = double
+      end
+    RUBY
+  end
+
   it 'ignores instance_doubles' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it do
         foo = instance_double("Foo")
       end
diff --git a/spec/rubocop/cop/rspec/void_expect_spec.rb b/spec/rubocop/cop/rspec/void_expect_spec.rb
index b4a75abe9..1ccf3ae74 100644
--- a/spec/rubocop/cop/rspec/void_expect_spec.rb
+++ b/spec/rubocop/cop/rspec/void_expect_spec.rb
@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::VoidExpect do
-  subject(:cop) { described_class.new }
-
   it 'registers offenses to void `expect`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'something' do
         something = 1
         expect(something)
@@ -14,7 +12,7 @@
   end
 
   it 'registers offenses to void `expect` when block has one expression' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'something' do
         expect(something)
         ^^^^^^^^^^^^^^^^^ Do not use `expect()` without `.to` or `.not_to`. Chain the methods or remove it.
@@ -23,7 +21,7 @@
   end
 
   it 'registers offenses to void `expect` with block' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       it 'something' do
         expect{something}
         ^^^^^^^^^^^^^^^^^ Do not use `expect()` without `.to` or `.not_to`. Chain the methods or remove it.
@@ -32,7 +30,7 @@
   end
 
   it 'accepts non-void `expect`' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'something' do
         expect(something).to be 1
       end
@@ -40,10 +38,32 @@
   end
 
   it 'accepts non-void `expect` with block' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       it 'something' do
         expect{something}.to raise_error(StandardError)
       end
     RUBY
   end
+
+  it 'ignores unrelated method named expect in an example block' do
+    expect_no_offenses(<<~RUBY)
+      it 'something' do
+        MyObject.expect(:foo)
+      end
+    RUBY
+  end
+
+  context 'when expect has no parent node' do
+    it 'does not register an offense' do
+      expect_no_offenses(<<~RUBY)
+        expect(something)
+      RUBY
+    end
+
+    it 'does not register an offense for unrelated expect with block' do
+      expect_no_offenses(<<~RUBY)
+        expect { block_contents }
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/cop/rspec/yield_spec.rb b/spec/rubocop/cop/rspec/yield_spec.rb
index 737243533..ef1a84a8f 100644
--- a/spec/rubocop/cop/rspec/yield_spec.rb
+++ b/spec/rubocop/cop/rspec/yield_spec.rb
@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
 RSpec.describe RuboCop::Cop::RSpec::Yield do
-  subject(:cop) { described_class.new }
-
   it 'flags `block.call`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       allow(foo).to receive(:bar) { |&block| block.call }
                                   ^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       allow(foo).to receive(:bar).and_yield
     RUBY
   end
 
   it 'flags multiple `block.call`' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       allow(foo).to receive(:bar) do |&block|
                                   ^^^^^^^^^^^ Use `.and_yield`.
         block.call
@@ -23,24 +21,24 @@
       end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       allow(foo).to receive(:bar).and_yield.and_yield
     RUBY
   end
 
   it 'flags `block.call` with arguments' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       allow(foo).to receive(:bar) { |&block| block.call(1, 2) }
                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       allow(foo).to receive(:bar).and_yield(1, 2)
     RUBY
   end
 
   it 'flags multiple `block.call` with arguments' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       allow(foo).to receive(:bar) do |&block|
                                   ^^^^^^^^^^^ Use `.and_yield`.
          block.call(1)
@@ -48,34 +46,51 @@
        end
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       allow(foo).to receive(:bar).and_yield(1).and_yield(2)
     RUBY
   end
 
   it 'flags `block.call` when `receive` is chained' do
-    expect_offense(<<-RUBY)
+    expect_offense(<<~RUBY)
       allow(foo).to receive(:bar).with(anything) { |&block| block.call }
                                                  ^^^^^^^^^^^^^^^^^^^^^^^ Use `.and_yield`.
     RUBY
 
-    expect_correction(<<-RUBY)
+    expect_correction(<<~RUBY)
       allow(foo).to receive(:bar).with(anything).and_yield
     RUBY
   end
 
   it 'ignores `receive` with no block arguments' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       allow(foo).to receive(:bar) { |block| block.call }
     RUBY
   end
 
   it 'ignores stub when `block.call` is not the only statement' do
-    expect_no_offenses(<<-RUBY)
+    expect_no_offenses(<<~RUBY)
       allow(foo).to receive(:bar) do |&block|
         result = block.call
         transform(result)
       end
     RUBY
   end
+
+  context 'when Ruby 2.7', :ruby27 do
+    it 'ignores `receive` with no block arguments' do
+      expect_no_offenses(<<~RUBY)
+        allow(foo).to receive(:bar) { _1.call }
+      RUBY
+    end
+
+    it 'ignores stub when `block.call` is not the only statement' do
+      expect_no_offenses(<<~RUBY)
+        allow(foo).to receive(:bar) do
+          result = _1.call
+          transform(result)
+        end
+      RUBY
+    end
+  end
 end
diff --git a/spec/rubocop/rspec/config_formatter_spec.rb b/spec/rubocop/rspec/config_formatter_spec.rb
index 8b7f163d9..51a90a9df 100644
--- a/spec/rubocop/rspec/config_formatter_spec.rb
+++ b/spec/rubocop/rspec/config_formatter_spec.rb
@@ -6,14 +6,26 @@
   let(:config) do
     {
       'AllCops' => {
-        'Setting' => 'fourty two'
+        'Setting' => 'forty two'
+      },
+      'Metrics/BlockLength' => {
+        'Exclude' => [
+          '**/*_spec.rb',
+          '**/spec/**/*'
+        ]
       },
       'RSpec/Foo' => {
-        'Config'      => 2,
-        'Enabled'     => true
+        'Config' => 2,
+        'Enabled' => true
       },
       'RSpec/Bar' => {
-        'Enabled'     => true
+        'Enabled' => true,
+        'Nullable' => nil
+      },
+      'RSpec/Baz' => {
+        'Enabled' => true,
+        'NegatedMatcher' => '~',
+        'StyleGuide' => '#buzz'
       }
     }
   end
@@ -25,6 +37,9 @@
       },
       'RSpec/Bar' => {
         'Description' => 'Wow'
+      },
+      'RSpec/Baz' => {
+        'Description' => 'Woof'
       }
     }
   end
@@ -32,21 +47,34 @@
   it 'builds a YAML dump with spacing between cops' do
     formatter = described_class.new(config, descriptions)
 
-    expect(formatter.dump).to eql(<<-YAML.gsub(/^\s+\|/, ''))
-      |---
-      |AllCops:
-      |  Setting: fourty two
-      |
-      |RSpec/Foo:
-      |  Config: 2
-      |  Enabled: true
-      |  Description: Blah
-      |  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Foo
-      |
-      |RSpec/Bar:
-      |  Enabled: true
-      |  Description: Wow
-      |  StyleGuide: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Bar
+    expect(formatter.dump).to eql(<<~YAML)
+      ---
+      AllCops:
+        Setting: forty two
+
+      Metrics/BlockLength:
+        Exclude:
+          - "**/*_spec.rb"
+          - "**/spec/**/*"
+
+      RSpec/Foo:
+        Config: 2
+        Enabled: true
+        Description: Blah
+        Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Foo
+
+      RSpec/Bar:
+        Enabled: true
+        Nullable: ~
+        Description: Wow
+        Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Bar
+
+      RSpec/Baz:
+        Enabled: true
+        NegatedMatcher: ~
+        StyleGuide: "#buzz"
+        Description: Woof
+        Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Baz
     YAML
   end
 end
diff --git a/spec/rubocop/rspec/description_extractor_spec.rb b/spec/rubocop/rspec/description_extractor_spec.rb
index db9794b45..9137b305b 100644
--- a/spec/rubocop/rspec/description_extractor_spec.rb
+++ b/spec/rubocop/rspec/description_extractor_spec.rb
@@ -6,7 +6,7 @@
 
 RSpec.describe RuboCop::RSpec::DescriptionExtractor do
   let(:yardocs) do
-    YARD.parse_string(<<-RUBY)
+    YARD.parse_string(<<~RUBY)
       # This is not a cop
       class RuboCop::Cop::Mixin::Sneaky
       end
@@ -14,7 +14,7 @@ class RuboCop::Cop::Mixin::Sneaky
       # This is not a concrete cop
       #
       # @abstract
-      class RuboCop::Cop::RSpec::Cop
+      class RuboCop::Cop::RSpec::Base
       end
 
       # Checks foo
@@ -22,7 +22,7 @@ class RuboCop::Cop::RSpec::Cop
       # Some description
       #
       # @note only works with foo
-      class RuboCop::Cop::RSpec::Foo < RuboCop::Cop::RSpec::Cop
+      class RuboCop::Cop::RSpec::Foo < RuboCop::Cop::RSpec::Base
         # Hello
         def bar
         end
@@ -32,21 +32,29 @@ class HelperClassForFoo
         end
       end
 
-      class RuboCop::Cop::RSpec::Undocumented < RuboCop::Cop::RSpec::Cop
+      class RuboCop::Cop::RSpec::Undocumented < RuboCop::Cop::RSpec::Base
         # Hello
         def bar
         end
       end
     RUBY
 
-    YARD::Registry.all
+    YARD::Registry.all(:class)
+  end
+
+  let(:temp_class) do
+    temp = RuboCop::Cop::Base.dup
+    temp.class_exec do
+      class << self
+        undef inherited
+        def inherited(*) end # rubocop:disable Lint/MissingSuper
+      end
+    end
+    temp
   end
 
   def stub_cop_const(name)
-    stub_const(
-      "RuboCop::Cop::RSpec::#{name}",
-      Class.new(RuboCop::Cop.const_get(:WorkaroundCop))
-    )
+    stub_const("RuboCop::Cop::RSpec::#{name}", Class.new(temp_class))
   end
 
   before do
diff --git a/spec/rubocop/rspec/example_group_spec.rb b/spec/rubocop/rspec/example_group_spec.rb
index e5fba6d70..88587e287 100644
--- a/spec/rubocop/rspec/example_group_spec.rb
+++ b/spec/rubocop/rspec/example_group_spec.rb
@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::RSpec::ExampleGroup do
+RSpec.describe RuboCop::RSpec::ExampleGroup, :config do
   include RuboCop::AST::Sexp
 
   subject(:group) { described_class.new(parse_source(source).ast) }
 
+  let(:cop_class) { RuboCop::Cop::RSpec::Base }
+
   let(:source) do
-    <<-RUBY
+    <<~RUBY
       RSpec.describe Foo do
         it 'does x' do
           x
@@ -38,6 +40,10 @@
     ].map { |node| RuboCop::RSpec::Example.new(node) }
   end
 
+  # Trigger setting of the `Language` in the case when this spec
+  # runs before cops' specs that set it.
+  before { cop.on_new_investigation }
+
   it 'exposes examples in scope' do
     expect(group.examples).to eql(example_nodes)
   end
diff --git a/spec/rubocop/rspec/example_spec.rb b/spec/rubocop/rspec/example_spec.rb
index 9cbfae4b1..f2eb9cc07 100644
--- a/spec/rubocop/rspec/example_spec.rb
+++ b/spec/rubocop/rspec/example_spec.rb
@@ -1,48 +1,54 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::RSpec::Example do
+RSpec.describe RuboCop::RSpec::Example, :config do
   include RuboCop::AST::Sexp
 
-  def example(source)
+  let(:cop_class) { RuboCop::Cop::RSpec::Base }
+
+  # Trigger setting of the `Language` in the case when this spec
+  # runs before cops' specs that set it.
+  before { cop.on_new_investigation }
+
+  def example_node(source)
     described_class.new(parse_source(source).ast)
   end
 
   it 'extracts doc string' do
-    expect(example("it('does x') { foo }").doc_string)
+    expect(example_node("it('does x') { foo }").doc_string)
       .to eq(s(:str, 'does x'))
   end
 
   it 'extracts doc string for unimplemented examples' do
-    expect(example("it('does x')").doc_string)
+    expect(example_node("it('does x')").doc_string)
       .to eq(s(:str, 'does x'))
   end
 
   it 'extracts interpolated doc string' do
-    expect(example("it(\"does \#{x}\")").doc_string)
+    expect(example_node('it("does #{x}")').doc_string)
       .to eq(s(:dstr, s(:str, 'does '), s(:begin, s(:send, nil, :x))))
   end
 
   it 'extracts symbol doc string' do
-    expect(example('it(:works_fine)').doc_string)
+    expect(example_node('it(:works_fine)').doc_string)
       .to eq(s(:sym, :works_fine))
   end
 
   it 'extracts method doc string' do
-    expect(example('it(description)').doc_string)
+    expect(example_node('it(description)').doc_string)
       .to eq(s(:send, nil, :description))
   end
 
   it 'returns nil for examples without doc strings' do
-    expect(example('it { foo }').doc_string).to be(nil)
+    expect(example_node('it { foo }').doc_string).to be_nil
   end
 
   it 'extracts keywords' do
-    expect(example("it('foo', :bar, baz: :qux) { a }").metadata)
+    expect(example_node("it('foo', :bar, baz: :qux) { a }").metadata)
       .to eq([s(:sym, :bar), s(:hash, s(:pair, s(:sym, :baz), s(:sym, :qux)))])
   end
 
   it 'extracts implementation' do
-    expect(example('it("foo") { bar; baz }').implementation)
+    expect(example_node('it("foo") { bar; baz }').implementation)
       .to eq(s(:begin, s(:send, nil, :bar), s(:send, nil, :baz)))
   end
 
@@ -52,19 +58,21 @@ def example(source)
   end
 
   describe 'value object semantics' do
+    # rubocop:disable RSpec/IdenticalEqualityAssertion
     it 'compares by value' do
       aggregate_failures 'equality semantics' do
-        expect(example('it("foo")')).to eq(example('it("foo")'))
-        expect(example('it("foo")')).not_to eq(example('it("bar")'))
+        expect(example_node('it("foo")')).to eq(example_node('it("foo")'))
+        expect(example_node('it("foo")')).not_to eq(example_node('it("bar")'))
       end
     end
+    # rubocop:enable RSpec/IdenticalEqualityAssertion
 
     it 'can be used as a key in a hash' do
       hash = {}
 
-      hash[example('it("foo")')] = 123
+      hash[example_node('it("foo")')] = 123
 
-      expect(hash[example('it("foo")')]).to be(123)
+      expect(hash[example_node('it("foo")')]).to be(123)
     end
 
     it 'computes #hash based on class and node' do
diff --git a/spec/rubocop/rspec/hook_spec.rb b/spec/rubocop/rspec/hook_spec.rb
index e5bdc2c1e..d105a1c7b 100644
--- a/spec/rubocop/rspec/hook_spec.rb
+++ b/spec/rubocop/rspec/hook_spec.rb
@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
-RSpec.describe RuboCop::RSpec::Hook do
+RSpec.describe RuboCop::RSpec::Hook, :config do
   include RuboCop::AST::Sexp
 
+  let(:cop_class) { RuboCop::Cop::RSpec::Base }
+
+  # Trigger setting of the `Language` in the case when this spec
+  # runs before cops' specs that set it.
+  before { cop.on_new_investigation }
+
   def hook(source)
     described_class.new(parse_source(source).ast)
   end
@@ -39,6 +45,11 @@ def hook(source)
         .to be(:each)
     end
 
+    it 'ignores invalid hooks' do
+      expect(hook('before(:invalid) { example_setup }').scope)
+        .to be_nil
+    end
+
     it 'classifies :each as an example hook' do
       expect(hook('before(:each) { }').example?).to be(true)
     end
@@ -53,14 +64,14 @@ def hook(source)
       end
     end
 
-    include_examples 'standardizes scope', 'before(:each) { }',    :each
-    include_examples 'standardizes scope', 'around(:example) { }', :each
-    include_examples 'standardizes scope', 'after { }',            :each
+    it_behaves_like 'standardizes scope', 'before(:each) { }',    :each
+    it_behaves_like 'standardizes scope', 'around(:example) { }', :each
+    it_behaves_like 'standardizes scope', 'after { }',            :each
 
-    include_examples 'standardizes scope', 'before(:all) { }',     :context
-    include_examples 'standardizes scope', 'around(:context) { }', :context
+    it_behaves_like 'standardizes scope', 'before(:all) { }',     :context
+    it_behaves_like 'standardizes scope', 'around(:context) { }', :context
 
-    include_examples 'standardizes scope', 'after(:suite) { }', :suite
+    it_behaves_like 'standardizes scope', 'after(:suite) { }', :suite
   end
 
   describe '#metadata' do
@@ -68,29 +79,62 @@ def metadata(source)
       hook(source).metadata.to_s
     end
 
+    if RUBY_VERSION >= '3.4'
+      let(:expected_focus) { 's(:sym, :focus) => true' }
+      let(:expected_invalid) { '{s(:sym, :invalid) => true}' }
+      let(:expected_special) { 's(:sym, :special) => true' }
+      let(:expected_symbol) { 's(:sym, :symbol) => true' }
+    else
+      let(:expected_focus) { 's(:sym, :focus)=>true' }
+      let(:expected_invalid) { '{s(:sym, :invalid)=>true}' }
+      let(:expected_special) { 's(:sym, :special)=>true' }
+      let(:expected_symbol) { 's(:sym, :symbol)=>true' }
+    end
+
     it 'extracts symbol metadata' do
       expect(metadata('before(:example, :special) { foo }'))
-        .to eq('{s(:sym, :special)=>true}')
+        .to eq("{#{expected_special}}")
     end
 
     it 'extracts hash metadata' do
       expect(metadata('before(:example, special: true) { foo }'))
-        .to eq('{s(:sym, :special)=>true}')
+        .to eq("{#{expected_special}}")
     end
 
     it 'combines symbol and hash metadata' do
       expect(metadata('before(:example, :symbol, special: true) { foo }'))
-        .to eq('{s(:sym, :symbol)=>true, s(:sym, :special)=>true}')
+        .to eq("{#{expected_symbol}, #{expected_special}}")
     end
 
     it 'extracts hash metadata with no scope given' do
       expect(metadata('before(special: true) { foo }'))
-        .to eq('{s(:sym, :special)=>true}')
+        .to eq("{#{expected_special}}")
     end
 
     it 'withstands no arguments' do
-      expect(metadata('before { foo }'))
-        .to be_empty
+      expect(metadata('before { foo }')).to be_empty
+    end
+
+    it 'returns the symbol even when an invalid symbol scope is provided' do
+      expect(metadata('before(:invalid) { foo }')).to eq(expected_invalid)
+    end
+
+    it 'extracts multiple symbol metadata' do
+      expect(metadata('before(:example, :special, :focus) { foo }'))
+        .to eq("{#{expected_special}, #{expected_focus}}")
+    end
+
+    it 'extracts multiple hash metadata' do
+      expect(metadata('before(:example, special: true, focus: true) { foo }'))
+        .to eq("{#{expected_special}, #{expected_focus}}")
+    end
+
+    it 'combines multiple symbol and hash metadata' do
+      expect(
+        metadata(
+          'before(:example, :symbol, special: true, focus: true) { foo }'
+        )
+      ).to eq("{#{expected_symbol}, #{expected_special}, #{expected_focus}}")
     end
   end
 end
diff --git a/spec/rubocop/rspec/language/selector_set_spec.rb b/spec/rubocop/rspec/language/selector_set_spec.rb
deleted file mode 100644
index 29313b83a..000000000
--- a/spec/rubocop/rspec/language/selector_set_spec.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RuboCop::RSpec::Language::SelectorSet do
-  subject(:selector_set) { described_class.new(%i[foo bar]) }
-
-  it 'composes sets' do
-    combined = selector_set + described_class.new(%i[baz])
-
-    expect(combined).to eq(described_class.new(%i[foo bar baz]))
-  end
-
-  it 'compares by value' do
-    expect(selector_set).not_to eq(described_class.new(%i[foo bar baz]))
-  end
-
-  describe '#include?' do
-    it 'returns false for selectors not in the set' do
-      expect(selector_set.include?(:baz)).to be(false)
-    end
-
-    it 'returns true for selectors in the set' do
-      expect(selector_set.include?(:foo)).to be(true)
-    end
-  end
-
-  describe '#node_pattern' do
-    it 'builds a node pattern' do
-      expect(selector_set.node_pattern).to eql(':foo :bar')
-    end
-  end
-
-  describe '#node_pattern_union' do
-    it 'builds a node pattern union' do
-      expect(selector_set.node_pattern_union).to eql('{:foo :bar}')
-    end
-  end
-
-  describe '#send_pattern' do
-    it 'builds a send matching pattern' do
-      expect(selector_set.send_pattern).to eql(
-        '(send {(const {nil? cbase} :RSpec) nil?} {:foo :bar} ...)'
-      )
-    end
-  end
-
-  describe '#block_pattern' do
-    it 'builds a block matching pattern' do
-      expect(selector_set.block_pattern).to eql(
-        '(block (send {(const {nil? cbase} :RSpec) nil?} {:foo :bar} ...) ...)'
-      )
-    end
-  end
-end
diff --git a/spec/rubocop/rspec/wording_spec.rb b/spec/rubocop/rspec/wording_spec.rb
index 80f7c8a43..7248f0dda 100644
--- a/spec/rubocop/rspec/wording_spec.rb
+++ b/spec/rubocop/rspec/wording_spec.rb
@@ -24,15 +24,20 @@
       'should wish me luck'                => 'wishes me luck',
       'should really only return one item' => 'really only returns one item',
       "shouldn't return something"         => 'does not return something',
+      'shouldn’t return something'         => 'does not return something',
       'SHOULD RETAIN UPPERCASE'            => 'RETAINS UPPERCASE',
       "shouldn't be true"                  => 'is not true',
+      'shouldn’t be true'                  => 'is not true',
       "SHOULDN'T BE true"                  => 'IS NOT true',
+      'SHOULDN’T BE true'                  => 'IS NOT true',
       "SHOULDN'T NOT RETAIN UPPERCASE"     => 'DOES NOT NOT RETAIN UPPERCASE',
+      'SHOULDN’T NOT RETAIN UPPERCASE'     => 'DOES NOT NOT RETAIN UPPERCASE',
       'should WORRY'                       => 'WORRIES',
       'should WISH me luck'                => 'WISHES me luck',
       ''                                   => '',
       'should'                             => '',
       "shouldn't"                          => 'does not',
+      'shouldn’t'                          => 'does not',
       'should not'                         => 'does not',
       'should fizz'                        => 'fizzes'
     }
diff --git a/spec/shared/autocorrect_behavior.rb b/spec/shared/autocorrect_behavior.rb
deleted file mode 100644
index d1db5e85d..000000000
--- a/spec/shared/autocorrect_behavior.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'autocorrect' do |original, corrected|
-  it "autocorrects `#{original}` to `#{corrected}`" do
-    autocorrected = autocorrect_source(original, 'spec/foo_spec.rb')
-
-    expect(autocorrected).to eql(corrected)
-  end
-end
diff --git a/spec/smoke_tests/weird_rspec_spec.rb b/spec/smoke_tests/weird_rspec_spec.rb
index debd97a65..aaef72617 100644
--- a/spec/smoke_tests/weird_rspec_spec.rb
+++ b/spec/smoke_tests/weird_rspec_spec.rb
@@ -11,6 +11,9 @@
   let (:foo) { 1 }
   let!   (:bar){}
 
+  bar = -> {}
+  let(:foo, &bar)
+
   let :a do end
 
   let(:bar) { <<-HEREDOC }
@@ -33,6 +36,17 @@
 
   let(:doop) { foo; 1 }
 
+  let('foo') { 1 }
+  let('foo' \
+      'bar') { 1 }
+
+  let!('foo') { 1 }
+  let!('foo' \
+      'bar') { 1 }
+
+  let("foo#{1}") { 1 }
+  let!("foo#{1}") { 1 }
+
   it {}
   specify {}
 
@@ -72,7 +86,7 @@
   end
 
   it_behaves_like :something
-  it_should_behave_like :something
+  it_should_behave_like :something if RSpec::Core::Version::STRING < '4.0'
 
   it_behaves_like :something do
     let(:foo) { 'bar' }
@@ -187,6 +201,8 @@ def announce
 RSpec.describe do end
 RSpec.shared_examples('pointless2') do end
 RSpec.shared_context('even pointless-er2') do end
+RSpec.describe
+RSpec.describe 'empty'
 
 class Broken
 end
@@ -194,7 +210,7 @@ class Broken
 RSpec.describe Broken do
 end
 
-RSpec.describe 'RubocopBug' do
+RSpec.describe 'RuboCopBug' do
   subject { true }
 
   before do
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index c15f55c71..b39d1e6fe 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,30 +1,37 @@
 # frozen_string_literal: true
 
 require 'rubocop'
-
 require 'rubocop/rspec/support'
 
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  SimpleCov.start
-end
+require 'simplecov' unless ENV['NO_COVERAGE']
 
 module SpecHelper
   ROOT = Pathname.new(__dir__).parent.freeze
 end
 
-spec_helper_glob = File.expand_path('{support,shared}/*.rb', __dir__)
-Dir.glob(spec_helper_glob).map(&method(:require))
+spec_helper_glob = '{support,shared,../lib/rubocop/rspec/shared_contexts}/*.rb'
+Dir
+  .glob(File.expand_path(spec_helper_glob, __dir__))
+  .sort
+  .each { |path| require path }
 
 RSpec.configure do |config|
-  config.define_derived_metadata(file_path: %r{/spec/rubocop/cop/}) do |meta|
+  # Set metadata so smoke tests are run on all cop specs
+  config.define_derived_metadata(
+    file_path: %r{/spec/rubocop/cop/rspec/(?!mixin/)}
+  ) do |meta|
     meta[:type] = :cop_spec
   end
 
+  # Include config shared context for all cop specs
+  config.define_derived_metadata(type: :cop_spec) do |meta|
+    meta[:config] = true
+  end
+
   config.order = :random
 
-  # Forbid RSpec from monkey patching any of our objects
-  config.disable_monkey_patching!
+  # Run focused tests with `fdescribe`, `fit`, `:focus` etc.
+  config.filter_run_when_matching :focus
 
   # We should address configuration warnings when we upgrade
   config.raise_errors_for_deprecations!
@@ -34,9 +41,11 @@ module SpecHelper
   config.raise_on_warning = true
 
   config.include(ExpectOffense)
+
+  config.include_context 'with default RSpec/Language config', :config
+  config.include_context 'smoke test', type: :cop_spec
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'rubocop-rspec'
diff --git a/spec/support/cli_spec_behavior.rb b/spec/support/cli_spec_behavior.rb
new file mode 100644
index 000000000..f1b590ed9
--- /dev/null
+++ b/spec/support/cli_spec_behavior.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'when cli spec behavior' do
+  include_context 'mock console output'
+
+  include FileHelper
+
+  before do
+    RuboCop::ConfigLoader.debug = false
+
+    # OPTIMIZE: Makes these specs faster. Work directory (the parent of
+    # .rubocop_cache) is removed afterwards anyway.
+    RuboCop::ResultCache.inhibit_cleanup = true
+  end
+
+  # Wrap all cli specs in `aggregate_failures` so that the expected and
+  # actual results of every expectation per example are shown. This is
+  # helpful because it shows information like expected and actual
+  # $stdout messages while not using `aggregate_failures` will only
+  # show information about expected and actual exit code
+  around { |example| aggregate_failures(&example) }
+
+  after { RuboCop::ResultCache.inhibit_cleanup = false }
+end
diff --git a/spec/support/expect_offense.rb b/spec/support/expect_offense.rb
index a05f2b0df..c86f52e8f 100644
--- a/spec/support/expect_offense.rb
+++ b/spec/support/expect_offense.rb
@@ -4,16 +4,37 @@
 #
 # This mixin is the same as rubocop's ExpectOffense except the default
 # filename ends with `_spec.rb`
+#
+# Cops assigned to departments may focus on different files, so it is
+# possible to override the inspected file name.
 module ExpectOffense
   include RuboCop::RSpec::ExpectOffense
 
   DEFAULT_FILENAME = 'example_spec.rb'
 
-  def expect_offense(source, filename = DEFAULT_FILENAME)
+  def expect_offense(source, filename = inspected_source_filename,
+                     *args, **kwargs)
     super
   end
 
-  def expect_no_offenses(source, filename = DEFAULT_FILENAME)
+  def expect_no_offenses(source, filename = inspected_source_filename)
     super
   end
+
+  def inspected_source_filename
+    DEFAULT_FILENAME
+  end
+
+  def expect_global_offense(source, file = nil, message = '')
+    processed_source = parse_source(source, file)
+    offenses = _investigate(cop, processed_source)
+    expect(offenses.size).to eq(1)
+    expect(offenses.first.message).to eq(message)
+  end
+
+  def expect_no_global_offenses(source, file = nil)
+    processed_source = parse_source(source, file)
+    offenses = _investigate(cop, processed_source)
+    expect(offenses.size).to eq(0)
+  end
 end
diff --git a/spec/support/file_helper.rb b/spec/support/file_helper.rb
new file mode 100644
index 000000000..976b3c38b
--- /dev/null
+++ b/spec/support/file_helper.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module FileHelper
+  def create_file(file_path, content)
+    file_path = File.expand_path(file_path)
+    create_dir file_path
+
+    File.open(file_path, 'w') do |file|
+      case content
+      when String
+        file.puts content
+      when Array
+        file.puts content.join("\n")
+      end
+    end
+  end
+
+  def create_dir(file_path)
+    dir_path = File.dirname(file_path)
+    FileUtils.makedirs dir_path
+  end
+end
diff --git a/tasks/cops_documentation.rake b/tasks/cops_documentation.rake
index c694b7001..691e6fb4f 100644
--- a/tasks/cops_documentation.rake
+++ b/tasks/cops_documentation.rake
@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require 'yard'
 require 'rubocop'
 require 'rubocop-rspec'
+require 'rubocop/cops_documentation_generator'
+require 'yard'
 
 YARD::Rake::YardocTask.new(:yard_for_generate_documentation) do |task|
   task.files = ['lib/rubocop/cop/**/*.rb']
@@ -11,268 +12,10 @@ end
 
 desc 'Generate docs of all cops departments'
 task generate_cops_documentation: :yard_for_generate_documentation do
-  def cops_of_department(cops, department)
-    cops.with_department(department).sort!
-  end
-
-  def cops_body(config, cop, description, examples_objects, pars)
-    content = h2(cop.cop_name)
-    content << properties(config, cop)
-    content << "#{description}\n"
-    content << examples(examples_objects) if examples_objects.count.positive?
-    content << configurations(pars)
-    content << references(config, cop)
-    content
-  end
-
-  def examples(examples_object)
-    examples_object.each_with_object(h3('Examples').dup) do |example, content|
-      content << h4(example.name) unless example.name == ''
-      content << code_example(example)
-    end
-  end
-
-  def properties(config, cop)
-    header = ['Enabled by default', 'Supports autocorrection']
-    enabled_by_default = config.for_cop(cop).fetch('Enabled')
-    content = [[
-      enabled_by_default ? 'Enabled' : 'Disabled',
-      cop.new.support_autocorrect? ? 'Yes' : 'No'
-    ]]
-    to_table(header, content) + "\n"
-  end
-
-  def h2(title)
-    content = +"\n"
-    content << "## #{title}\n"
-    content << "\n"
-    content
-  end
-
-  def h3(title)
-    content = +"\n"
-    content << "### #{title}\n"
-    content << "\n"
-    content
-  end
-
-  def h4(title)
-    content = +"#### #{title}\n"
-    content << "\n"
-    content
-  end
-
-  def code_example(ruby_code)
-    content = +"```ruby\n"
-    content << ruby_code.text
-      .gsub('@good', '# good')
-      .gsub('@bad', '# bad').strip
-    content << "\n```\n"
-    content
-  end
-
-  def configurations(pars)
-    return '' if pars.empty?
-
-    header = ['Name', 'Default value', 'Configurable values']
-    configs = pars.each_key.reject { |key| key.start_with?('Supported') }
-    content = configs.map do |name|
-      configurable = configurable_values(pars, name)
-      default = format_table_value(pars[name])
-      [name, default, configurable]
-    end
-
-    h3('Configurable attributes') + to_table(header, content)
-  end
-
-  # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
-  def configurable_values(pars, name)
-    case name
-    when /^Enforced/
-      supported_style_name = RuboCop::Cop::Util.to_supported_styles(name)
-      format_table_value(pars[supported_style_name])
-    when 'IndentationWidth'
-      'Integer'
-    else
-      case pars[name]
-      when String
-        'String'
-      when Integer
-        'Integer'
-      when Float
-        'Float'
-      when true, false
-        'Boolean'
-      when Array
-        'Array'
-      else
-        ''
-      end
-    end
-  end
-  # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
-
-  def to_table(header, content)
-    table = [
-      header.join(' | '),
-      Array.new(header.size, '---').join(' | ')
-    ]
-    table.concat(content.map { |c| c.join(' | ') })
-    table.join("\n") + "\n"
-  end
-
-  # rubocop:disable Metrics/MethodLength
-  def format_table_value(val)
-    value =
-      case val
-      when Array
-        if val.empty?
-          '`[]`'
-        else
-          val.map { |config| format_table_value(config) }.join(', ')
-        end
-      else
-        "`#{val.nil? ? '<none>' : val}`"
-      end
-    value.gsub("#{Dir.pwd}/", '').rstrip
-  end
-  # rubocop:enable Metrics/MethodLength
-
-  def cop_urls(config, cop)
-    rubocop_version = Gem::Version.new(RuboCop::Version::STRING)
-
-    # Since Rubocop v0.75.0 and above, MessageAnnotator#new changed from:
-    #   def initialize(config, cop_config, options)
-    # to:
-    #   def initialize(config, cop_name, cop_config, options)
-    #
-    # Since this library has a loose Rubocop dependency, we select the
-    # right arguments based on the installed version.
-    #
-    # TODO: When Rubocop < 0.75 is no longer supported, remove the second half
-    # of this condition.
-
-    if rubocop_version >= Gem::Version.new('0.75.0')
-      RuboCop::Cop::MessageAnnotator.new(
-        config, cop.name, config.for_cop(cop), {}
-      ).urls
-    else
-      RuboCop::Cop::MessageAnnotator.new(config, config.for_cop(cop), {}).urls
-    end
-  end
-
-  def references(config, cop)
-    urls = cop_urls(config, cop)
-
-    return '' if urls.empty?
-
-    content = h3('References')
-    content << urls.map { |url| "* [#{url}](#{url})" }.join("\n")
-    content << "\n"
-    content
-  end
-
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
-  def print_cops_of_department(cops, department, config)
-    selected_cops = cops_of_department(cops, department).select do |cop|
-      cop.to_s.start_with?('RuboCop::Cop::RSpec')
-    end
-    return if selected_cops.empty?
-
-    content = +"# #{department}\n"
-    selected_cops.each do |cop|
-      content << print_cop_with_doc(cop, config)
-    end
-    file_name = "#{Dir.pwd}/manual/cops_#{department.downcase}.md"
-    File.open(file_name, 'w') do |file|
-      puts "* generated #{file_name}"
-      file.write(content.strip + "\n")
-    end
-  end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/MethodLength
-
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
-  def print_cop_with_doc(cop, config)
-    t = config.for_cop(cop)
-    non_display_keys = %w[Description Enabled StyleGuide Reference]
-    pars = t.reject { |k| non_display_keys.include? k }
-    description = 'No documentation'
-    examples_object = []
-    YARD::Registry.all(:class).detect do |code_object|
-      next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
-
-      description = code_object.docstring unless code_object.docstring.blank?
-      examples_object = code_object.tags('example')
-    end
-    cops_body(config, cop, description, examples_object, pars)
-  end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/MethodLength
-
-  # rubocop:disable Metrics/AbcSize
-  # rubocop:disable Metrics/MethodLength
-  def table_of_content_for_department(cops, department)
-    selected_cops = cops_of_department(cops, department.to_sym).select do |cop|
-      cop.to_s.start_with?('RuboCop::Cop::RSpec')
-    end
-    return if selected_cops.empty?
-
-    type_title = department[0].upcase + department[1..-1]
-    filename = "cops_#{department.downcase}.md"
-    content = +"#### Department [#{type_title}](#{filename})\n\n"
-    selected_cops.each do |cop|
-      anchor = cop.cop_name.sub('/', '').downcase
-      content << "* [#{cop.cop_name}](#{filename}##{anchor})\n"
-    end
-
-    content
-  end
-  # rubocop:enable Metrics/AbcSize
-  # rubocop:enable Metrics/MethodLength
-
-  def print_table_of_contents(cops)
-    path = "#{Dir.pwd}/manual/cops.md"
-    original = File.read(path)
-    content = +"<!-- START_COP_LIST -->\n"
-
-    content << table_contents(cops)
-
-    content << "\n<!-- END_COP_LIST -->"
-
-    content = original.sub(
-      /<!-- START_COP_LIST -->.+<!-- END_COP_LIST -->/m, content
-    )
-    File.write(path, content)
-  end
-
-  def table_contents(cops)
-    cops
-      .departments
-      .map(&:to_s)
-      .sort
-      .map { |department| table_of_content_for_department(cops, department) }
-      .reject(&:nil?)
-      .join("\n")
-  end
-
-  def main
-    cops   = RuboCop::Cop::Cop.registry
-    config = RuboCop::ConfigLoader.load_file('config/default.yml')
-
-    YARD::Registry.load!
-    cops.departments.sort!.each do |department|
-      print_cops_of_department(cops, department, config)
-    end
-
-    print_table_of_contents(cops)
-  ensure
-    RuboCop::ConfigLoader.default_configuration = nil
-  end
-
-  main
+  generator = CopsDocumentationGenerator.new(
+    departments: %w[RSpec], plugin_name: 'rubocop-rspec'
+  )
+  generator.call
 end
 
 desc 'Syntax check for the documentation comments'
@@ -281,7 +24,7 @@ task documentation_syntax_check: :yard_for_generate_documentation do
 
   ok = true
   YARD::Registry.load!
-  cops = RuboCop::Cop::Cop.registry
+  cops = RuboCop::Cop::Registry.global
   cops.each do |cop|
     examples = YARD::Registry.all(:class).find do |code_object|
       next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
@@ -290,17 +33,15 @@ task documentation_syntax_check: :yard_for_generate_documentation do
     end
 
     examples.to_a.each do |example|
-      begin
-        buffer = Parser::Source::Buffer.new('<code>', 1)
-        buffer.source = example.text
-        parser = Parser::Ruby25.new(RuboCop::AST::Builder.new)
-        parser.diagnostics.all_errors_are_fatal = true
-        parser.parse(buffer)
-      rescue Parser::SyntaxError => e
-        path = example.object.file
-        puts "#{path}: Syntax Error in an example. #{e}"
-        ok = false
-      end
+      buffer = Parser::Source::Buffer.new('<code>', 1)
+      buffer.source = example.text
+      parser = Parser::Ruby25.new(RuboCop::AST::Builder.new)
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.parse(buffer)
+    rescue Parser::SyntaxError => e
+      path = example.object.file
+      puts "#{path}: Syntax Error in an example. #{e}"
+      ok = false
     end
   end
   abort unless ok
diff --git a/tasks/create_release_notes.rake b/tasks/create_release_notes.rake
new file mode 100644
index 000000000..6ba815e7a
--- /dev/null
+++ b/tasks/create_release_notes.rake
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+desc 'Create release notes for the most recent version.'
+task :create_release_notes do
+  CreateReleaseNotes.call
+end
+
+# Create release notes from the most recent version in the CHANGELOG.md file.
+module CreateReleaseNotes
+  module_function
+
+  def call
+    release_notes = new_version_changes.strip
+    contributor_links = user_links(release_notes)
+
+    File.open('relnotes.md', 'w') do |file|
+      file << release_notes
+      file << "\n\n"
+      file << contributor_links
+      file << "\n"
+    end
+  end
+
+  def new_version_changes
+    changelog = File.read('CHANGELOG.md')
+    _, _, new_changes, _older_changes = changelog.split(/^## .*$/, 4)
+    new_changes
+  end
+
+  def user_links(text)
+    names = text.scan(/\[@(\S+)\]/).map(&:first).uniq.sort
+    names.map { |name| "[@#{name}]: https://github.com/#{name}" }.join("\n")
+  end
+end
diff --git a/tasks/cut_release.rake b/tasks/cut_release.rake
new file mode 100644
index 000000000..1ffa53035
--- /dev/null
+++ b/tasks/cut_release.rake
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'bump'
+
+namespace :cut_release do
+  def update_file(path)
+    content = File.read(path)
+    File.write(path, yield(content))
+  end
+
+  %w[major minor patch pre].each do |release_type|
+    desc "Cut a new #{release_type} release and update documents."
+    task release_type do
+      run(release_type)
+    end
+  end
+
+  def version_sans_patch(version)
+    version.split('.').take(2).join('.')
+  end
+
+  # Replace `<<next>>` (and variations) with version being cut.
+  def update_cop_versions(version)
+    update_file('config/default.yml') do |default|
+      default.gsub(/['"]?<<\s*next\s*>>['"]?/i,
+                   "'#{version_sans_patch(version)}'")
+    end
+    RuboCop::ConfigLoader.default_configuration = nil # invalidate loaded conf
+  end
+
+  def update_docs(version)
+    update_file('docs/antora.yml') do |antora_metadata|
+      antora_metadata.sub('version: ~',
+                          "version: '#{version_sans_patch(version)}'")
+    end
+  end
+
+  def add_header_to_changelog(version)
+    update_file('CHANGELOG.md') do |changelog|
+      changelog.sub("## Master (Unreleased)\n\n",
+                    "\\0## #{version} (#{Time.now.strftime('%F')})\n\n")
+    end
+  end
+
+  def run(release_type)
+    old_version = Bump::Bump.current
+    Bump::Bump.run(release_type, commit: false, bundle: false, tag: false)
+    new_version = Bump::Bump.current
+
+    update_cop_versions(new_version)
+    `bundle exec rake generate_cops_documentation`
+    update_docs(new_version) if %w[major minor].include?(release_type)
+    add_header_to_changelog(new_version)
+
+    puts "Changed version from #{old_version} to #{new_version}."
+  end
+end