rubocop-capybara 2.22.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad193ece2721896d4cb226a3c9de94552e09a2c522f73c178869371649ff32e1
-  data.tar.gz: 1fefe61d2408bbe3767d8e220198c461cffbc73d9c4dba6a6ae65ccac0f54d5c
+  metadata.gz: 984aeaf86c3452b30f2eab372f0ec1e1a6dcd3fb3a2efe6e6d60f4e435a9d84d
+  data.tar.gz: d5336d9300145f0803d3883c195cbcbdcecb0a8de54660d3fcf682166d4e8cd0
 SHA512:
-  metadata.gz: 4c59e247dac850cc730bf1e7d0f0b090622f75411c9eabd25f7ad6bb553651227021c0c39b3ec490239254353cb992f190c0ab9ad6dfa5b119f155186c7199b3
-  data.tar.gz: c2b6063f6a2c3e603fe27ac11546d14bb21b96a24f1a18e01ea117370d882edb03c621259e4d41179788b1d77eb2288c5d7109c5ef13e1ef28d065a01a6ae136
+  metadata.gz: 2c08f6500d0ce4907ebea18f476a6da57411bd35b3e8c7ebe2be619efd2ef8b03999c7c5724eab4013e7febe656d043e9dd341f2cf1e4dfe8e81b945369d2e57
+  data.tar.gz: 578287adeb808e1c534134f17dbf2ebf4e7fe91433b90344f0704168deccc98328da9aca3210b4c653960437b788e36f067bee0b4bf7b85d5d926fbeda00b59a

data/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## Edge (Unreleased)
 
+## 3.0.0 (2026-06-22)
+
+- Enable pending cops by default for the 3.0 release. ([@ydah])
+- Remove the deprecated `Capybara/ClickLinkOrButtonStyle` cop. ([@ydah])
+- Remove obsolete cop name migration config for the 2.x to 3.0 transition. ([@ydah])
+
+## 2.23.0 (2026-04-30)
+
+- Bump RuboCop requirement to +1.81. ([@ydah])
+- Add new `Capybara/RSpec/HaveContent` cop. ([@nzlaura])
+- Move the department associated with `Capybara::RSpecMatchers` to `Capybara/RSpec/*`. ([@ydah])
+  - Rename `Capybara/CurrentPathExpectation` to `Capybara/RSpec/CurrentPathExpectation`
+  - Rename `Capybara/SpecificMatcher` to `Capybara/RSpec/SpecificMatcher`
+  - Rename `Capybara/NegationMatcher` to `Capybara/RSpec/NegationMatcher`
+  - Rename `Capybara/NegationMatcherAfterVisit` to `Capybara/RSpec/NegationMatcherAfterVisit`
+  - Rename `Capybara/VisibilityMatcher` to `Capybara/RSpec/VisibilityMatcher`
+- Split `Capybara/MatchStyle` into `Capybara/AssertStyle` and `Capybara/RSpec/MatchStyle`. ([@ydah])
+- Fix a false positive for `Capybara/FindAllFirst` when using logical operators with `all('...')[0]`. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/FindAllFirst` when `find` or `all` with `match: :first` uses a receiver and mark autocorrection as unsafe. ([@ydah])
+- Fix an error for `Capybara/RSpec/HaveSelector` when passing only a selector type. ([@ydah])
+
 ## 2.22.1 (2025-03-12)
 
 - Fix incorrect plugin version. ([@koic])
@@ -13,6 +34,7 @@
 - Add a new `Capybara/NegationMatcherAfterVisit` cop. ([@ydah])
 - Fix an error for `Capybara/RSpec/HaveSelector` when passing no arguments. ([@earlopain])
 - Make RuboCop Capybara work as a RuboCop plugin. ([@bquorning])
+- Fix an incorrect autocorrect for `Capybara/RedundantWithinFind` when escape required css selector. ([@ydah])
 
 ## 2.21.0 (2024-06-08)
 
@@ -89,6 +111,7 @@
 [@darhazer]: https://github.com/Darhazer
 [@earlopain]: https://github.com/earlopain
 [@koic]: https://github.com/koic
+[@nzlaura]: https://github.com/nzlaura
 [@onumis]: https://github.com/onumis
 [@oskarsezerins]: https://github.com/OskarsEzerins
 [@pirj]: https://github.com/pirj

data/README.md

@@ -76,7 +76,7 @@ In your `.rubocop.yml`, you may treat the Capybara cops just like any other
 cop. For example:
 
 ```yaml
-Capybara/SpecificMatcher:
+Capybara/RSpec/SpecificMatcher:
   Exclude:
     - spec/my_spec.rb
 ```

data/config/default.yml

@@ -15,98 +15,96 @@ Capybara/AmbiguousClick:
   VersionAdded: '2.22'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/AmbiguousClick
 
-Capybara/ClickLinkOrButtonStyle:
-  Description: Checks for methods of button or link clicks.
-  Enabled: false
-  VersionAdded: '2.19'
-  VersionChanged: '2.22'
-  EnforcedStyle: link_or_button
-  SupportedStyles:
-    - link_or_button
-    - strict
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/ClickLinkOrButtonStyle
-
-Capybara/CurrentPathExpectation:
-  Description: Checks that no expectations are set on Capybara's `current_path`.
+Capybara/AssertStyle:
+  Description: Checks for usage of deprecated assert style method.
   Enabled: true
-  VersionAdded: '1.18'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/CurrentPathExpectation
+  VersionAdded: '2.23'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/AssertStyle
 
 Capybara/FindAllFirst:
   Description: Enforces use of `first` instead of `all` with `first` or `[0]`.
-  Enabled: pending
+  Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '2.22'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/FindAllFirst
 
-Capybara/MatchStyle:
-  Description: Checks for usage of deprecated style methods.
-  Enabled: pending
-  VersionAdded: '2.17'
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/MatchStyle
-
-Capybara/NegationMatcher:
-  Description: Enforces use of `have_no_*` or `not_to` for negated expectations.
-  Enabled: pending
-  VersionAdded: '2.14'
-  VersionChanged: '2.20'
-  EnforcedStyle: have_no
-  SupportedStyles:
-    - have_no
-    - not_to
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/NegationMatcher
-
-Capybara/NegationMatcherAfterVisit:
-  Description: Do not allow negative matchers to be used immediately after `visit`.
-  Enabled: pending
-  VersionAdded: '2.22'
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/NegationMatcherAfterVisit
-
 Capybara/RedundantWithinFind:
   Description: Checks for redundant `within find(...)` calls.
-  Enabled: pending
+  Enabled: true
   VersionAdded: '2.20'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RedundantWithinFind
 
 Capybara/SpecificActions:
   Description: Checks for there is a more specific actions offered by Capybara.
-  Enabled: pending
+  Enabled: true
   VersionAdded: '2.14'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/SpecificActions
 
 Capybara/SpecificFinders:
   Description: Checks if there is a more specific finder offered by Capybara.
-  Enabled: pending
+  Enabled: true
   VersionAdded: '2.13'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/SpecificFinders
 
-Capybara/SpecificMatcher:
-  Description: Checks for there is a more specific matcher offered by Capybara.
-  Enabled: pending
-  VersionAdded: '2.12'
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/SpecificMatcher
+Capybara/RSpec:
+  Enabled: true
+  Include: *1
 
-Capybara/VisibilityMatcher:
-  Description: Checks for boolean visibility in Capybara finders.
+Capybara/RSpec/CurrentPathExpectation:
+  Description: Checks that no expectations are set on Capybara's `current_path`.
   Enabled: true
-  VersionAdded: '1.39'
-  VersionChanged: '2.0'
-  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/VisibilityMatcher
+  VersionAdded: '1.18'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/CurrentPathExpectation
 
-Capybara/RSpec:
+Capybara/RSpec/HaveContent:
+  Description: Checks for usage of `have_content` and `have_no_content`.
   Enabled: true
-  Include: *1
+  VersionAdded: '2.23'
+  VersionChanged: '3.0'
+  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`.
-  Enabled: pending
+  Enabled: true
   DefaultSelector: css
   VersionAdded: '2.19'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/HaveSelector
 
+Capybara/RSpec/MatchStyle:
+  Description: Checks for usage of deprecated style methods in RSpec matchers.
+  Enabled: true
+  VersionAdded: '2.23'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/MatchStyle
+
+Capybara/RSpec/NegationMatcher:
+  Description: Enforces use of `have_no_*` or `not_to` for negated expectations.
+  Enabled: true
+  VersionAdded: '2.14'
+  VersionChanged: '3.0'
+  EnforcedStyle: have_no
+  SupportedStyles:
+    - have_no
+    - not_to
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/NegationMatcher
+
+Capybara/RSpec/NegationMatcherAfterVisit:
+  Description: Do not allow negative matchers to be used immediately after `visit`.
+  Enabled: true
+  VersionAdded: '2.22'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/NegationMatcherAfterVisit
+
 Capybara/RSpec/PredicateMatcher:
   Description: Prefer using predicate matcher over using predicate method directly.
-  Enabled: pending
+  Enabled: true
   Strict: true
   EnforcedStyle: inflected
   AllowedExplicitMatchers: []
@@ -114,4 +112,19 @@ Capybara/RSpec/PredicateMatcher:
     - inflected
     - explicit
   VersionAdded: '2.19'
+  VersionChanged: '3.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/PredicateMatcher
+
+Capybara/RSpec/SpecificMatcher:
+  Description: Checks for there is a more specific matcher offered by Capybara.
+  Enabled: true
+  VersionAdded: '2.12'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/SpecificMatcher
+
+Capybara/RSpec/VisibilityMatcher:
+  Description: Checks for boolean visibility in Capybara finders.
+  Enabled: true
+  VersionAdded: '1.39'
+  VersionChanged: '3.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/VisibilityMatcher

data/lib/rubocop/capybara/plugin.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'pathname'
+
 require 'lint_roller'
 
 module RuboCop
@@ -24,9 +26,6 @@ module RuboCop
       def rules(_context)
         project_root = Pathname.new(__dir__).join('../../..')
 
-        obsoletion = project_root.join('config', 'obsoletion.yml')
-        ConfigObsoletion.files << obsoletion if obsoletion.exist?
-
         LintRoller::Rules.new(
           type: :path,
           config_format: :rubocop,

data/lib/rubocop/capybara/version.rb

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

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for usage of deprecated assert style method.
+      #
+      # @example
+      #   # bad
+      #   page.find(:css, '#first').assert_style(display: 'block')
+      #
+      #   # good
+      #   page.find(:css, '#first').assert_matches_style(display: 'block')
+      #
+      class AssertStyle < ::RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = 'Use `assert_matches_style` instead of `assert_style`.'
+        RESTRICT_ON_SEND = %i[assert_style].freeze
+
+        def on_send(node)
+          method_node = node.loc.selector
+          add_offense(method_node) do |corrector|
+            corrector.replace(method_node, 'assert_matches_style')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,13 @@ module RuboCop
     module Capybara
       # 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).
+      #
       # @example
       #
       #   # bad
@@ -46,6 +53,7 @@ module RuboCop
         def on_all_first(node)
           return unless (parent = node.parent)
           return unless find_all_first?(parent)
+          return if part_of_logical_operator?(parent)
 
           range = range_between(node.loc.selector.begin_pos,
                                 parent.loc.selector.end_pos)
@@ -60,9 +68,11 @@ module RuboCop
           include_match_first?(node) do |hash|
             selector = ([node.first_argument.source] + replaced_hash(hash))
               .join(', ')
-            add_offense(node,
+            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(node, "first(#{selector})")
+              corrector.replace(range, "first(#{selector})")
             end
           end
         end
@@ -72,6 +82,10 @@ module RuboCop
             arg == 'match: :first'
           end
         end
+
+        def part_of_logical_operator?(node)
+          node.ancestors.any?(&:operator_keyword?)
+        end
       end
     end
   end

data/lib/rubocop/cop/capybara/mixin/css_selector.rb

@@ -83,6 +83,18 @@ module RuboCop
           normalize = selector.gsub(/(\\[>,+~]|\(.*\))/, '')
           normalize.match?(/[ >,+~]/)
         end
+
+        # @param str [String]
+        # @param quote [String] the quote character used (' or ")
+        # @return [String]
+        # @example
+        #   css_escape('foo.bar', "'") # => 'foo\.bar'
+        #   css_escape('foo.bar', '"') # => 'foo\\.bar'
+        #   css_escape('foo', "'") # => 'foo'
+        def css_escape(str, quote = "'")
+          escaped_dot = quote == '"' ? '\\\\\\\\.' : '\\\\.'
+          str.gsub('.', escaped_dot)
+        end
       end
     end
   end

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

@@ -27,6 +27,7 @@ module RuboCop
       #   end
       #
       class RedundantWithinFind < ::RuboCop::Cop::Base
+        include CssSelector
         extend AutoCorrector
         MSG = 'Redundant `within %<method>s(...)` call detected.'
         RESTRICT_ON_SEND = %i[within].freeze
@@ -53,13 +54,25 @@ module RuboCop
         end
 
         def replaced(node)
-          replaced = node.arguments.map(&:source).join(', ')
-          if node.method?(:find_by_id)
-            replaced.sub(/\A(["'])/, '\1#')
+          unless node.method?(:find_by_id)
+            return node.arguments.map(&:source).join(', ')
+          end
+
+          if node.first_argument.str_type?
+            build_escaped_selector(node.first_argument, node)
           else
-            replaced
+            node.arguments.map(&:source).join(', ')
+              .sub(/\A(["'])/, '\1#')
           end
         end
+
+        def build_escaped_selector(first_arg, node)
+          quote = first_arg.source[0]
+          escaped_id = CssSelector.css_escape(first_arg.value, quote)
+          rest_args = node.arguments.drop(1).map(&:source)
+
+          ["#{quote}##{escaped_id}#{quote}", *rest_args].join(', ')
+        end
       end
     end
   end

data/lib/rubocop/cop/capybara/rspec/current_path_expectation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks that no expectations are set on Capybara's `current_path`.
+        #
+        # The
+        # https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher]
+        # should be used on `page` to set expectations on Capybara's
+        # current path, since it uses
+        # https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality]
+        # which ensures that preceding actions (like `click_link`) have
+        # completed.
+        #
+        # This cop does not support autocorrection in some cases.
+        #
+        # @example
+        #   # bad
+        #   expect(current_path).to eq('/callback')
+        #   expect(page.current_path).to eq('/callback')
+        #
+        #   # good
+        #   expect(page).to have_current_path('/callback', ignore_query: true)
+        #
+        #   # bad (does not support autocorrection when `match` with a variable)
+        #   expect(page).to match(variable)
+        #
+        class CurrentPathExpectation < ::RuboCop::Cop::Base
+          extend AutoCorrector
+          include RangeHelp
+
+          MSG = 'Do not set an RSpec expectation on `current_path` in ' \
+                'Capybara feature specs - instead, use the ' \
+                '`have_current_path` matcher on `page`'
+
+          RESTRICT_ON_SEND = %i[expect].freeze
+
+          # @!method expectation_set_on_current_path(node)
+          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')
+          # @!method as_is_matcher(node)
+          def_node_matcher :as_is_matcher, <<~PATTERN
+            (send
+              #expectation_set_on_current_path ${:to :to_not :not_to}
+              ${(send nil? :eq ...) (send nil? :match (regexp ...))})
+          PATTERN
+
+          # @!method regexp_node_matcher(node)
+          def_node_matcher :regexp_node_matcher, <<~PATTERN
+            (send
+              #expectation_set_on_current_path ${:to :to_not :not_to}
+              $(send nil? :match $any_str))
+          PATTERN
+
+          def self.autocorrect_incompatible_with
+            [Style::TrailingCommaInArguments]
+          end
+
+          def on_send(node)
+            expectation_set_on_current_path(node) do
+              add_offense(node.loc.selector) do |corrector|
+                next unless node.chained?
+
+                autocorrect(corrector, node)
+              end
+            end
+          end
+
+          private
+
+          def autocorrect(corrector, node)
+            as_is_matcher(node.parent) do |to_sym, matcher_node|
+              rewrite_expectation(corrector, node, to_sym, matcher_node)
+            end
+
+            regexp_node_matcher(node.parent) do |to_sym, matcher_node, regexp|
+              rewrite_expectation(corrector, node, to_sym, matcher_node)
+              convert_regexp_node_to_literal(corrector, matcher_node, regexp)
+            end
+          end
+
+          def rewrite_expectation(corrector, node, to_symbol, matcher_node)
+            corrector.replace(node.first_argument, '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_argument_parentheses(corrector, matcher_node.first_argument)
+            add_ignore_query_options(corrector, node, matcher_node)
+          end
+
+          def convert_regexp_node_to_literal(corrector, matcher_node,
+                                             regexp_node)
+            str_node = matcher_node.first_argument
+            regexp_expr = regexp_node_to_regexp_expr(regexp_node)
+            corrector.replace(str_node, regexp_expr)
+          end
+
+          def regexp_node_to_regexp_expr(regexp_node)
+            if regexp_node.xstr_type?
+              "/\#{`#{regexp_node.value.value}`}/"
+            else
+              Regexp.new(regexp_node.value).inspect
+            end
+          end
+
+          def add_argument_parentheses(corrector, arg_node)
+            return unless method_call_with_no_parentheses?(arg_node)
+
+            first_argument_range = range_with_surrounding_space(
+              arg_node.first_argument.source_range, side: :left
+            )
+            corrector.insert_before(first_argument_range, '(')
+            corrector.insert_after(arg_node.last_argument, ')')
+          end
+
+          def method_call_with_no_parentheses?(arg_node)
+            arg_node.send_type? && arg_node.arguments? &&
+              !arg_node.parenthesized?
+          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 `match` matcher.
+          def add_ignore_query_options(corrector, node, matcher_node)
+            return if matcher_node.method?(:match)
+
+            expectation_node = node.parent.last_argument
+            expectation_last_child = expectation_node.children.last
+            corrector.insert_after(expectation_last_child,
+                                   ', ignore_query: true')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/rspec/have_content.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks for usage of `have_content` and `have_no_content`.
+        #
+        # Capybara provides `have_text` and `have_no_text` matchers that are
+        # more concise and preferred over their aliases `have_content` and
+        # `have_no_content`.
+        #
+        # @example
+        #   # bad
+        #   expect(page).to have_content('capy')
+        #   expect(page).to have_no_content('bara')
+        #
+        #   # good
+        #   expect(page).to have_text('capy')
+        #   expect(page).to have_no_text('bara')
+        #
+        class HaveContent < ::RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Prefer `%<good>s` over `%<bad>s`.'
+          RESTRICT_ON_SEND = %i[have_content have_no_content].freeze
+          PREFERRED_METHOD = {
+            'have_content' => 'have_text',
+            'have_no_content' => 'have_no_text'
+          }.freeze
+
+          def on_send(node)
+            method_node = node.loc.selector
+            add_offense(method_node,
+                        message: message(method_node)) do |corrector|
+              corrector.replace(method_node,
+                                PREFERRED_METHOD[method_node.source])
+            end
+          end
+          alias on_csend on_send
+
+          private
+
+          def message(node)
+            format(MSG, good: PREFERRED_METHOD[node.source], bad: node.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara/rspec/have_selector.rb

@@ -52,9 +52,10 @@ module RuboCop
 
           def on_select_with_type(node, type)
             return unless SELECTORS.include?(type.value)
+            return unless (locator = node.arguments[1])
 
             add_offense(node, message: message_typed(type)) do |corrector|
-              corrector.remove(deletion_range(type, node.arguments[1]))
+              corrector.remove(deletion_range(type, locator))
               corrector.replace(node.loc.selector, "have_#{type.value}")
             end
           end

data/lib/rubocop/cop/capybara/rspec/match_style.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks for usage of deprecated style methods in RSpec matchers.
+        #
+        # @example when using `has_style?`
+        #   # bad
+        #   expect(page.find(:css, 'first')
+        #     .has_style?(display: 'block')).to be true
+        #
+        #   # good
+        #   expect(page.find(:css, 'first')
+        #     .matches_style?(display: 'block')).to be true
+        #
+        # @example when using `have_style`
+        #   # bad
+        #   expect(page).to have_style(display: 'block')
+        #
+        #   # good
+        #   expect(page).to match_style(display: 'block')
+        #
+        class MatchStyle < ::RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+          RESTRICT_ON_SEND = %i[has_style? have_style].freeze
+          PREFERRED_METHOD = {
+            'has_style?' => 'matches_style?',
+            'have_style' => 'match_style'
+          }.freeze
+
+          def on_send(node)
+            method_node = node.loc.selector
+            preferred = PREFERRED_METHOD[method_node.source]
+            add_offense(method_node,
+                        message: message(preferred, method_node)) do |corrector|
+              corrector.replace(method_node, preferred)
+            end
+          end
+
+          private
+
+          def message(preferred, method_node)
+            format(MSG, good: preferred, bad: method_node.source)
+          end
+        end
+      end
+    end
+  end
+end