rubocop-capybara 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984aeaf86c3452b30f2eab372f0ec1e1a6dcd3fb3a2efe6e6d60f4e435a9d84d
-  data.tar.gz: d5336d9300145f0803d3883c195cbcbdcecb0a8de54660d3fcf682166d4e8cd0
+  metadata.gz: 5b880f22effca543e3fcbabf13ff06e0055eabeddec7342ec5ff2375a6ceb336
+  data.tar.gz: b4937b0aa90a9bb9e095ca0d19418a7ee294bf1bc6cabc84c2001bd8fa46aa92
 SHA512:
-  metadata.gz: 2c08f6500d0ce4907ebea18f476a6da57411bd35b3e8c7ebe2be619efd2ef8b03999c7c5724eab4013e7febe656d043e9dd341f2cf1e4dfe8e81b945369d2e57
-  data.tar.gz: 578287adeb808e1c534134f17dbf2ebf4e7fe91433b90344f0704168deccc98328da9aca3210b4c653960437b788e36f067bee0b4bf7b85d5d926fbeda00b59a
+  metadata.gz: d141ff264d07fb784bc62ec4d47f04153b033e599d3297a1f9b063c8398b877e507cdb3e575c3497ff96612b4acea6ad15a82694b28c03913fd1e59b02423c91
+  data.tar.gz: 04abfbff88016558648d3cff263ce0b3ef2413dda3a3f381849d26e3a3bbffcd4b7762c76020d8db0892609e2585af7a0413b41fd20712caec161738f3fa852d

data/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## Edge (Unreleased)
 
+## 3.1.0 (2026-10-16)
+
+- Add new `Capybara/UnorderedWindowAccess` cop. ([@ydah])
+- Add new `Capybara/AbsoluteXPathInElementScope` cop. ([@ydah])
+- Add new `Capybara/AlwaysTrueCountQuery` cop. ([@ydah])
+- Add new `Capybara/RSpec/CurrentUrlExpectation` cop. ([@ydah])
+- Add new `Capybara/ModalMethodWithoutBlock` cop. ([@ydah])
+- Add new `Capybara/NativeAttribute` cop. ([@ydah])
+- Add new `Capybara/VisibilityOption` cop. ([@ydah])
+- Add new `Capybara/ChainedFind` cop. ([@ydah])
+- Add new `Capybara/IgnoredQueryOption` cop. ([@ydah])
+- Add new `Capybara/RSpec/FindElementValueEq` cop. ([@ydah])
+- Recognize `have_element` and `have_no_element` in the RSpec negation cops. ([@ydah])
+- Detect `have_no_selector` in `Capybara/RSpec/HaveSelector`. ([@ydah])
+- Autocorrect `visible: true` in `Capybara/RSpec/VisibilityMatcher` for known selectors. ([@ydah])
+- Add support for using `find` with `:link` and `:field` in `Capybara/SpecificFinders` cop. ([@ydah])
+- Speed up loading rubocop-capybara by lazily loading only the cops needed for a run. This requires RuboCop 1.89.0+. ([@koic])
+- Fix false positives in `Capybara/RSpec/SpecificMatcher` for input types excluded by `have_field`. ([@ydah])
+- Avoid interpolating literal `#{...}`, `#@...`, and `#$...` patterns in `Capybara/RSpec/CurrentPathExpectation` and `Capybara/RSpec/CurrentUrlExpectation` autocorrection. ([@ydah])
+- Fix false positives and negatives for `Capybara/SpecificActions` when CSS attribute values contain spaces. ([@ydah])
+- Honor `DefaultSelector: null` in selector-dependent cops, including `Capybara/RSpec/HaveSelector`. ([@ydah])
+- Fix false positives for custom elements in `Capybara/SpecificActions` and `Capybara/RSpec/SpecificMatcher`. ([@ydah])
+- Avoid unsafe block autocorrection and unnecessary receiver parentheses in `Capybara/RSpec/PredicateMatcher`. ([@ydah])
+- Fix a crash in `Capybara/RSpec/CurrentPathExpectation` for invalid regexp strings. ([@ydah])
+- Fix `Capybara/SpecificFinders` when CSS id values are `true` or `false`. ([@ydah])
+- Fix a crash in `Capybara/SpecificActions` for blank `find` selectors. ([@ydah])
+- Fix reversed autocorrection in `Capybara/RSpec/PredicateMatcher` for `eql` and `equal` boolean matchers. ([@ydah])
+- Avoid errors and unsafe autocorrection in `Capybara/SpecificFinders` with dynamic `class:` options. ([@ydah])
+- Fix incorrect autocorrections and missed offenses for non-CSS locators in `Capybara/SpecificFinders`. ([@ydah])
+- Use the `:id` selector when `Capybara/RedundantWithinFind` autocorrects `find_by_id`, preserving special and dynamic IDs. ([@ydah])
+- Avoid unsafe `find_field` autocorrections for input types and boolean attributes in `Capybara/SpecificFinders`. ([@ydah])
+- Fix false positives and incorrect autocorrections for `Capybara/FindAllFirst` when `find` or `all` uses `match: :first`. ([@ydah])
+- Avoid `Capybara/FindAllFirst` offenses when the result is used with safe navigation or as a condition. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/RedundantWithinFind` when `find_by_id` uses a dynamic id. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/RedundantWithinFind` when a finder call has a block argument. ([@ydah])
+- Fix a false positive for `Capybara/RSpec/HaveSelector` when `DefaultSelector` is unsupported. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/SpecificFinders` when a selector class is empty or contains an escaped dot. ([@ydah])
+- Fix a false positive for `Capybara/SpecificFinders` when an id selector contains unsupported CSS identifier syntax. ([@ydah])
+- Fix a false negative for `Capybara/RSpec/NegationMatcherAfterVisit` when using `to_not`. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/RSpec/PredicateMatcher` when `EnforcedStyle: explicit` and `expect` actual is a complex expression. ([@ydah])
+- Fix `Capybara/RSpec/CurrentPathExpectation` autocorrection for `match` when the URL has a query string. ([@ydah])
+- Fix a false positive for `Capybara/SpecificActions` when `click` uses arguments or a block. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/SpecificFinders` when a selector class is used with nested `class:` options. ([@ydah])
+- Fix CSS attribute parsing when attribute values contain quotes. ([@ydah])
+- Fix CSS attribute parsing to return raw values and format Ruby literals in autocorrection. ([@ydah])
+- Fix a false negative for `Capybara/SpecificFinders` when using `find` with input field attributes. ([@ydah])
+
 ## 3.0.0 (2026-06-22)
 
 - Enable pending cops by default for the 3.0 release. ([@ydah])

data/config/default.yml

@@ -9,6 +9,18 @@ Capybara:
     - "**/*_steps.rb"
     - "**/features/step_definitions/**/*"
 
+Capybara/AbsoluteXPathInElementScope:
+  Description: Checks for absolute XPath searches on Capybara elements.
+  Enabled: pending
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/AbsoluteXPathInElementScope
+
+Capybara/AlwaysTrueCountQuery:
+  Description: Checks for positive queries that succeed when there are no matches.
+  Enabled: pending
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/AlwaysTrueCountQuery
+
 Capybara/AmbiguousClick:
   Description: Specify the exact target to click on.
   Enabled: false
@@ -22,6 +34,13 @@ Capybara/AssertStyle:
   VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/AssertStyle
 
+Capybara/ChainedFind:
+  Description: Avoid chaining `find` methods and combine selectors.
+  Enabled: pending
+  DefaultSelector: css
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/ChainedFind
+
 Capybara/FindAllFirst:
   Description: Enforces use of `first` instead of `all` with `first` or `[0]`.
   Enabled: true
@@ -30,6 +49,26 @@ Capybara/FindAllFirst:
   VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/FindAllFirst
 
+Capybara/IgnoredQueryOption:
+  Description: Checks for query options that have no effect in Capybara.
+  Enabled: pending
+  DefaultSelector: css
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/IgnoredQueryOption
+
+Capybara/ModalMethodWithoutBlock:
+  Description: Checks that modal handling methods are called with a block.
+  Enabled: pending
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/ModalMethodWithoutBlock
+
+Capybara/NativeAttribute:
+  Description: Enforces use of `Element#[]` instead of `native.attribute`.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/NativeAttribute
+
 Capybara/RedundantWithinFind:
   Description: Checks for redundant `within find(...)` calls.
   Enabled: true
@@ -51,6 +90,19 @@ Capybara/SpecificFinders:
   VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/SpecificFinders
 
+Capybara/UnorderedWindowAccess:
+  Description: Checks positional access to Capybara windows, whose order is undefined.
+  Enabled: pending
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/UnorderedWindowAccess
+
+Capybara/VisibilityOption:
+  Description: Checks for boolean values passed to Capybara's `visible` option.
+  Enabled: pending
+  DefaultSelector: css
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/VisibilityOption
+
 Capybara/RSpec:
   Enabled: true
   Include: *1
@@ -62,6 +114,20 @@ Capybara/RSpec/CurrentPathExpectation:
   VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/CurrentPathExpectation
 
+Capybara/RSpec/CurrentUrlExpectation:
+  Description: Checks expectations on `current_url` that bypass Capybara's waiting.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/CurrentUrlExpectation
+
+Capybara/RSpec/FindElementValueEq:
+  Description: Checks for expectations on the value of an element found by Capybara.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '3.1'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/FindElementValueEq
+
 Capybara/RSpec/HaveContent:
   Description: Checks for usage of `have_content` and `have_no_content`.
   Enabled: true
@@ -70,7 +136,7 @@ Capybara/RSpec/HaveContent:
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/HaveContent
 
 Capybara/RSpec/HaveSelector:
-  Description: Use `have_css` or `have_xpath` instead of `have_selector`.
+  Description: Use CSS or XPath matchers instead of generic selector matchers.
   Enabled: true
   DefaultSelector: css
   VersionAdded: '2.19'
@@ -123,8 +189,10 @@ Capybara/RSpec/SpecificMatcher:
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/SpecificMatcher
 
 Capybara/RSpec/VisibilityMatcher:
-  Description: Checks for boolean visibility in Capybara finders.
+  Description: Checks for boolean visibility in Capybara RSpec matchers.
   Enabled: true
+  SafeAutoCorrect: false
+  DefaultSelector: css
   VersionAdded: '1.39'
-  VersionChanged: '3.0'
+  VersionChanged: "<<next>>"
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/VisibilityMatcher

data/lib/rubocop/capybara/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Capybara
     # Version information for the Capybara RuboCop plugin.
     module Version
-      STRING = '3.0.0'
+      STRING = '3.1.0'
     end
   end
 end

data/lib/rubocop/cop/capybara/absolute_x_path_in_element_scope.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for absolute XPath searches on Capybara elements.
+      #
+      # An XPath starting with `//` searches from the document root, even when
+      # the query is called on an element. Use `.//` to stay within it.
+      # Direct RSpec `let` and named `subject` element definitions are
+      # recognized.
+      #
+      # @example
+      #   # bad
+      #   page.find('.dialog').find(:xpath, '//button')
+      #   dialog = page.find('.dialog')
+      #   dialog.find(:xpath, '//button')
+      #   RSpec.describe 'dialog' do
+      #     let(:dialog) { find('.dialog') }
+      #     it { dialog.find(:xpath, '//button') }
+      #   end
+      #
+      #   # good
+      #   page.find('.dialog').find(:xpath, './/button')
+      #   page.find(:xpath, '//button')
+      #
+      class AbsoluteXPathInElementScope < RuboCop::Cop::Base
+        include CapybaraHelp
+
+        MSG = 'Use `.//` for an XPath search within an element.'
+        RESTRICT_ON_SEND = %i[find all find_all first].freeze
+        RSPEC_GROUPS = %i[
+          describe context feature shared_examples shared_context
+        ].freeze
+        RSPEC_HELPERS = %i[let let! subject].freeze
+
+        # @!method xpath_literal(node)
+        def_node_matcher :xpath_literal, '(call _ _ (sym :xpath) $(str _) ...)'
+
+        # @!method element_finder?(node)
+        def_node_matcher :element_finder?, <<~PATTERN
+          (call #capybara_receiver? :find ...)
+        PATTERN
+
+        def on_send(node)
+          xpath = xpath_literal(node)
+          return unless xpath&.value&.start_with?('//')
+          return unless element_receiver?(node.receiver)
+
+          add_offense(xpath)
+        end
+        alias on_csend on_send
+
+        private
+
+        def element_receiver?(node)
+          return true if node&.call_type? && element_finder?(node)
+          return element_finder?(local_variable_value(node)) if node&.lvar_type?
+
+          element_finder?(rspec_helper_value(node)) if node&.call_type?
+        end
+
+        def rspec_helper_value(node)
+          return unless node.receiver.nil? && node.arguments.empty?
+
+          node.each_ancestor(:block).each do |group|
+            next unless rspec_group?(group)
+
+            definition = named_helper(group, node.method_name)
+            return definition.body if definition
+          end
+          nil
+        end
+
+        def rspec_group?(block)
+          call = block.send_node
+          return false unless RSPEC_GROUPS.include?(call.method_name)
+
+          call.receiver.nil? || (call.receiver.const_type? &&
+            call.receiver.const_name == 'RSpec')
+        end
+
+        def named_helper(group, name)
+          body = group.body
+          statements = body.begin_type? ? body.children : [body]
+          statements.reverse_each.find do |statement|
+            named_rspec_helper?(statement, name)
+          end
+        end
+
+        def named_rspec_helper?(statement, name)
+          return false unless statement.block_type?
+
+          call = statement.send_node
+          return false if call.receiver
+          return false unless RSPEC_HELPERS.include?(call.method_name)
+
+          argument = call.first_argument
+          argument&.sym_type? && argument.value == name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/always_true_count_query.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for positive queries that succeed when there are no matches.
+      #
+      # @example
+      #   # bad
+      #   expect(page).to have_css('.item', minimum: 0)
+      #   page.has_css?('.item', minimum: 0)
+      #
+      #   # good
+      #   expect(page).to have_css('.item')
+      #   expect(page).to have_css('.item', minimum: 0, maximum: 2)
+      #   all('.item', minimum: 0)
+      #
+      class AlwaysTrueCountQuery < RuboCop::Cop::Base
+        include CapybaraHelp
+
+        MSG = '`minimum: 0` makes this positive query succeed with no matches.'
+        OTHER_COUNT_OPTIONS = %i[count maximum between].freeze
+        RESTRICT_ON_SEND = QueryMethods.names(:selector).select do |name|
+          name = name.to_s
+          name.start_with?('assert_', 'has_', 'have_', 'must_have_') &&
+            !name.start_with?('assert_no_', 'has_no_', 'have_no_')
+        end.freeze
+
+        # @!method zero_minimum?(node)
+        def_node_matcher :zero_minimum?, '(pair (sym :minimum) (int 0))'
+
+        def on_send(node)
+          return unless capybara_receiver?(node.receiver)
+          return unless positive_usage?(node)
+
+          minimum = always_true_minimum(node.last_argument)
+          add_offense(minimum) if minimum
+        end
+        alias on_csend on_send
+
+        private
+
+        def positive_usage?(node)
+          return true unless node.method_name.to_s.start_with?('have_')
+
+          parent = node.parent
+          parent&.send_type? && parent.method?(:to) &&
+            parent.first_argument == node
+        end
+
+        def always_true_minimum(options)
+          return unless known_options?(options)
+
+          pairs = options.pairs
+          return if pairs.any? { |pair| other_count_option?(pair) }
+
+          minimum = pairs.select { |pair| pair.key.value == :minimum }
+          minimum.first if minimum.one? && zero_minimum?(minimum.first)
+        end
+
+        def known_options?(options)
+          return false unless options&.hash_type? && !options.braces?
+
+          options.children.all? do |child|
+            child.pair_type? && child.key.sym_type?
+          end
+        end
+
+        def other_count_option?(pair)
+          OTHER_COUNT_OPTIONS.include?(pair.key.value) && !pair.value.nil_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/ambiguous_click.rb

@@ -17,7 +17,7 @@ module RuboCop
       #   click_link('foo')
       #   click_button('foo')
       #
-      class AmbiguousClick < ::RuboCop::Cop::Base
+      class AmbiguousClick < RuboCop::Cop::Base
         MSG = 'Use `click_link` or `click_button` instead of `%<method>s`.'
         RESTRICT_ON_SEND = %i[click_link_or_button click_on].freeze
 

data/lib/rubocop/cop/capybara/assert_style.rb

@@ -12,7 +12,7 @@ module RuboCop
       #   # good
       #   page.find(:css, '#first').assert_matches_style(display: 'block')
       #
-      class AssertStyle < ::RuboCop::Cop::Base
+      class AssertStyle < RuboCop::Cop::Base
         extend AutoCorrector
 
         MSG = 'Use `assert_matches_style` instead of `assert_style`.'

data/lib/rubocop/cop/capybara/chained_find.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Avoid chaining `find` methods and combine selectors.
+      #
+      # Combining selectors into a single `find` call is more efficient than
+      # chaining multiple `find` calls, as it reduces the number of DOM queries.
+      # Only recognizable Capybara finder chains with string locators are
+      # checked.
+      # Set `DefaultSelector` to match `Capybara.default_selector`, or to
+      # `null` if it varies at runtime. Autocorrection requires `css` and
+      # literal strings.
+      #
+      # @example
+      #   # bad
+      #   page.find('#foo').find('.bar')
+      #   page.find('#foo').find('.bar').find('.baz')
+      #
+      #   # good
+      #   page.find('#foo .bar')
+      #   page.find('#foo .bar .baz')
+      #   find('#form').find(:button, 'Save')
+      #
+      class ChainedFind < RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+        include CapybaraHelp
+
+        MSG = 'Avoid chaining `find` methods. ' \
+              'Combine the selectors into a single `find` call.'
+        MSG_WITH_COMBINED = 'Use `find(%<combined>s)` instead of ' \
+                            'chaining `find` methods.'
+        RESTRICT_ON_SEND = %i[find].freeze
+
+        # @!method single_string_find?(node)
+        def_node_matcher :single_string_find?, <<~PATTERN
+          (call _ :find (str $_))
+        PATTERN
+
+        def on_send(node)
+          return unless chained_find?(node)
+
+          find_receiver = find_receiver(node.receiver)
+          return unless find_receiver
+          return unless string_locators?(node, find_receiver)
+          return unless capybara_receiver?(find_receiver.receiver)
+
+          register_offense(node, find_receiver)
+        end
+        alias on_csend on_send
+
+        private
+
+        def chained_find?(node)
+          node.method?(:find) && node.receiver
+        end
+
+        def string_locators?(node, receiver)
+          node.first_argument&.type?(:str, :dstr) &&
+            receiver.first_argument&.type?(:str, :dstr)
+        end
+
+        def find_receiver(receiver)
+          return unwrapped_receiver(receiver) if receiver.block_type?
+
+          receiver if receiver.call_type? && receiver.method?(:find)
+        end
+
+        def unwrapped_receiver(block_node)
+          send_node = block_node.send_node
+          send_node if send_node.method?(:find)
+        end
+
+        def register_offense(node, find_receiver)
+          if safe_to_autocorrect?(node, find_receiver)
+            add_correctable_offense(node, find_receiver)
+          else
+            add_offense(node)
+          end
+        end
+
+        def add_correctable_offense(node, find_receiver)
+          combined = combined_selector(node, find_receiver)
+          message = format(
+            MSG_WITH_COMBINED,
+            combined: selector_literal(combined)
+          )
+          return add_offense(node, message: message) if nested_find?(node)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement(node, combined))
+          end
+        end
+
+        def nested_find?(node)
+          node.parent&.call_type? &&
+            node.parent.method?(:find) &&
+            node.parent.receiver == node
+        end
+
+        def safe_to_autocorrect?(node, receiver)
+          cop_config['DefaultSelector'].to_s == 'css' &&
+            single_string_argument?(node) &&
+            single_string_argument?(receiver) &&
+            node.type == receiver.type &&
+            safe_selectors?(node)
+        end
+
+        def safe_selectors?(node)
+          current = node
+          while current&.call_type? && current.method?(:find)
+            return false unless single_string_argument?(current)
+
+            return false if unsafe_selector?(current.first_argument.value)
+
+            current = current.receiver
+          end
+
+          true
+        end
+
+        def unsafe_selector?(selector)
+          selector.match?(/(?<!\\),/) || selector.start_with?('//', './/')
+        end
+
+        def single_string_argument?(node)
+          node.arguments.one? &&
+            !node.block_node &&
+            single_string_find?(node)
+        end
+
+        def combined_selector(node, receiver)
+          selectors = collect_selectors(receiver)
+          current = node.first_argument.value
+
+          "#{selectors} #{current}"
+        end
+
+        def collect_selectors(node)
+          [].tap do |selectors|
+            current = node
+            while (selector = single_string_find?(current))
+              selectors.unshift(selector)
+              current = current.receiver
+              break unless current&.call_type? && current.method?(:find)
+            end
+          end.join(' ')
+        end
+
+        def replacement(node, combined_selector)
+          root = chain_root(node)
+          receiver_source = root.receiver&.source
+          find_call = "find(#{selector_literal(combined_selector)})"
+
+          [receiver_source, find_call].compact.join(root.loc.dot&.source || '.')
+        end
+
+        def selector_literal(selector)
+          return selector.inspect if selector.match?(/['\\]/)
+
+          "'#{selector}'"
+        end
+
+        def chain_root(node)
+          root = node
+          while root.receiver&.call_type? && root.receiver.method?(:find)
+            root = root.receiver
+          end
+          root
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/find_all_first.rb

@@ -6,29 +6,25 @@ module RuboCop
       # Enforces use of `first` instead of `all` with `first` or `[0]`.
       #
       # @safety
-      #   This cop's autocorrection is unsafe because `all` returns a
-      #   `Capybara::Result` (an enumerable collection), while `first`
-      #   returns a single `Capybara::Node::Element`. Replacing `all`
-      #   with `first` may break code that depends on the return value
-      #   being a collection (e.g. calling `.each` on the result).
+      #   With default options, `all(...).first` and `all(...)[0]` return
+      #   `nil` when no element matches, while `first(...)` raises an
+      #   exception. Autocorrection can break code that depends on `nil`.
       #
       # @example
       #
       #   # bad
       #   all('a').first
       #   all('a')[0]
-      #   find('a', match: :first)
-      #   all('a', match: :first)
       #
       #   # good
       #   first('a')
       #
-      class FindAllFirst < ::RuboCop::Cop::Base
+      class FindAllFirst < RuboCop::Cop::Base
         extend AutoCorrector
         include RangeHelp
 
         MSG = 'Use `first(%<selector>s)`.'
-        RESTRICT_ON_SEND = %i[all find].freeze
+        RESTRICT_ON_SEND = %i[all].freeze
 
         # @!method find_all_first?(node)
         def_node_matcher :find_all_first?, <<~PATTERN
@@ -38,22 +34,10 @@ module RuboCop
           }
         PATTERN
 
-        # @!method include_match_first?(node)
-        def_node_matcher :include_match_first?, <<~PATTERN
-          (send _ {:find :all} _ $(hash <(pair (sym :match) (sym :first)) ...>))
-        PATTERN
-
         def on_send(node)
-          on_all_first(node)
-          on_match_first(node)
-        end
-
-        private
-
-        def on_all_first(node)
           return unless (parent = node.parent)
           return unless find_all_first?(parent)
-          return if part_of_logical_operator?(parent)
+          return if nil_sensitive_use?(parent)
 
           range = range_between(node.loc.selector.begin_pos,
                                 parent.loc.selector.end_pos)
@@ -64,27 +48,15 @@ module RuboCop
           end
         end
 
-        def on_match_first(node)
-          include_match_first?(node) do |hash|
-            selector = ([node.first_argument.source] + replaced_hash(hash))
-              .join(', ')
-            range = range_between(node.loc.selector.begin_pos,
-                                  node.source_range.end_pos)
-            add_offense(range,
-                        message: format(MSG, selector: selector)) do |corrector|
-              corrector.replace(range, "first(#{selector})")
-            end
-          end
-        end
+        private
 
-        def replaced_hash(hash)
-          hash.child_nodes.flat_map(&:source).reject do |arg|
-            arg == 'match: :first'
-          end
-        end
+        def nil_sensitive_use?(node)
+          return true if node.ancestors.any?(&:operator_keyword?)
 
-        def part_of_logical_operator?(node)
-          node.ancestors.any?(&:operator_keyword?)
+          parent = node.parent
+          (parent&.csend_type? && parent.receiver == node) ||
+            (parent&.type?(:if, :while, :until) &&
+             parent.condition == node)
         end
       end
     end