rubocop-capybara 2.18.0 → 2.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb7f795cc80f072b94781f2339e781cccf9922ad2303c09111c0e34a4af264f8
-  data.tar.gz: d2ae47b522208177b7c93338973c8a144dfbccca2f817f0797b531f8c89e50b9
+  metadata.gz: 963a68452b58c47db1d1d9e7f9201db0a98a8b70bb8089473b406911fa5cc33e
+  data.tar.gz: 58e60dd5ff6097695a1029b9e37414209f7c26d2da0d16cbc6b808c8cd56efd8
 SHA512:
-  metadata.gz: 36b58f29500840c7dc34c2c2ed55856ff08cdd7ca41822209a9388204948903be89cf13c3065da7cfed3e8332f3433b3293087c8de1cf1266f093fadef2fa69d
-  data.tar.gz: 5b961abac7ae8dd46708ec9649718a23596bde9e45bcc48f7d9e818c2a116d5fda3de0653cf3aa8e56d11ed11ebcb94e24ef49ee0653e739a26d43d2383c2152
+  metadata.gz: cec93e7919aeefbb1f2b2c13f1f0caeb7627c5556f85fe219f107b6520237cccd792ad4713905dfb47151f0bcb82e04d4bd0034a7a747b741e607ea9d4de5e54
+  data.tar.gz: 3e359ec71065b5daf64cdb080d8ddfad4f6144778ad7fb89d932aa083353547663a1316efe7f9e9fd3cb7bca6a6f012812ea7f18e00c76a8af22316f24325f7c

data/CHANGELOG.md

@@ -2,10 +2,28 @@
 
 ## Edge (Unreleased)
 
+## 2.20.0 (2024-01-03)
+
+- Change to default `EnforcedStyle: link_or_button` for `Capybara/ClickLinkOrButtonStyle` cop. ([@ydah])
+- Fix a false negative for `RSpec/HaveSelector` when first argument is dstr node. ([@ydah])
+- Add new `Capybara/RedundantWithinFind` cop. ([@ydah])
+- Fix an invalid attributes parse when name with multiple `[]` for `Capybara/SpecificFinders` and `Capybara/SpecificActions` and `Capybara/SpecificMatcher`. ([@ydah])
+- Change to default `EnforcedStyle: have_no` for `Capybara/NegationMatcher` cop. ([@ydah])
+- Fix a false positive for `Capybara/SpecificMatcher` when `text:` or `exact_text:` with regexp. ([@ydah])
+
+## 2.19.0 (2023-09-20)
+
+- Add new `Capybara/RSpec/PredicateMatcher` cop. ([@ydah])
+- Add new `Capybara/RSpec/HaveSelector` cop. ([@ydah])
+- Add new `Capybara/ClickLinkOrButtonStyle` cop. ([@ydah])
+- Fix a false positive for `Capybara/SpecificFinders` when `find` with kind option. ([@ydah])
+- Fix an incorrect autocorrect for `Capybara/CurrentPathExpectation`. ([@ydah])
+- Drop Ruby 2.6 support. ([@ydah])
+
 ## 2.18.0 (2023-04-21)
 
 - Fix an offense message for `Capybara/SpecificFinders`. ([@ydah])
-- Expand `Capybara/NegationMatcher` to support `have_content` ([@OskarsEzerins])
+- Expand `Capybara/NegationMatcher` to support `have_content`. ([@OskarsEzerins])
 - Fix an incorrect autocorrect for `Capybara/CurrentPathExpectation` when matcher's argument is a method with a argument and no parentheses. ([@ydah])
 
 ## 2.17.1 (2023-02-13)

data/README.md

@@ -17,7 +17,7 @@ gem install rubocop-capybara
 
 or if you use bundler put this in your `Gemfile`
 
-```
+```ruby
 gem 'rubocop-capybara', require: false
 ```
 

data/config/default.yml

@@ -2,13 +2,24 @@
 Capybara:
   Enabled: true
   DocumentationBaseURL: https://docs.rubocop.org/rubocop-capybara
-  Include:
+  Include: &1
     - "**/*_spec.rb"
     - "**/spec/**/*"
     - "**/test/**/*"
     - "**/*_steps.rb"
     - "**/features/step_definitions/**/*"
 
+Capybara/ClickLinkOrButtonStyle:
+  Description: Checks for methods of button or link clicks.
+  Enabled: pending
+  VersionAdded: '2.19'
+  VersionChanged: '2.20'
+  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`.
   Enabled: true
@@ -26,12 +37,19 @@ Capybara/NegationMatcher:
   Description: Enforces use of `have_no_*` or `not_to` for negated expectations.
   Enabled: pending
   VersionAdded: '2.14'
-  EnforcedStyle: not_to
+  VersionChanged: '2.20'
+  EnforcedStyle: have_no
   SupportedStyles:
     - have_no
     - not_to
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/NegationMatcher
 
+Capybara/RedundantWithinFind:
+  Description: Checks for redundant `within find(...)` calls.
+  Enabled: pending
+  VersionAdded: '2.20'
+  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
@@ -56,3 +74,26 @@ Capybara/VisibilityMatcher:
   VersionAdded: '1.39'
   VersionChanged: '2.0'
   Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/VisibilityMatcher
+
+Capybara/RSpec:
+  Enabled: true
+  Include: *1
+
+Capybara/RSpec/HaveSelector:
+  Description: Use `have_css` or `have_xpath` instead of `have_selector`.
+  Enabled: pending
+  DefaultSelector: css
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/HaveSelector
+
+Capybara/RSpec/PredicateMatcher:
+  Description: Prefer using predicate matcher over using predicate method directly.
+  Enabled: pending
+  Strict: true
+  EnforcedStyle: inflected
+  AllowedExplicitMatchers: []
+  SupportedStyles:
+    - inflected
+    - explicit
+  VersionAdded: '2.19'
+  Reference: https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/Capybara/RSpec/PredicateMatcher

data/lib/rubocop/capybara/config_formatter.rb

@@ -7,7 +7,7 @@ module RuboCop
     # Builds a YAML config file from two config hashes
     class ConfigFormatter
       EXTENSION_ROOT_DEPARTMENT = %r{^(Capybara/)}.freeze
-      SUBDEPARTMENTS = [].freeze
+      SUBDEPARTMENTS = %(Capybara/RSpec)
       AMENDMENTS = [].freeze
       COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-capybara/RuboCop/Cop/'
 

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.18.0'
+      STRING = '2.20.0'
     end
   end
 end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for methods of button or link clicks.
+      #
+      # By default, prefer to use `click_link_or_button` or `click_on`.
+      # These methods offer a weaker coupling between the test and HTML,
+      # allowing for a more faithful reflection of how the user behaves.
+      #
+      # You can set `EnforcedStyle: strict` to prefer the use of
+      # `click_link` and `click_button`, but this is a deprecated setting.
+      #
+      # @example EnforcedStyle: link_or_button (default)
+      #   # bad
+      #   click_link('foo')
+      #   click_button('foo')
+      #
+      #   # good
+      #   click_link_or_button('foo')
+      #   click_on('foo')
+      #
+      # @example EnforcedStyle: strict
+      #   # bad
+      #   click_link_or_button('foo')
+      #   click_on('foo')
+      #
+      #   # good
+      #   click_link('foo')
+      #   click_button('foo')
+      #
+      class ClickLinkOrButtonStyle < ::RuboCop::Cop::Base
+        include ConfigurableEnforcedStyle
+
+        MSG_STRICT =
+          'Use `click_link` or `click_button` instead of `%<method>s`.'
+        MSG_CLICK_LINK_OR_BUTTON =
+          'Use `click_link_or_button` or `click_on` instead of `%<method>s`.'
+        STRICT_METHODS = %i[click_link click_button].freeze
+        CLICK_LINK_OR_BUTTON = %i[click_link_or_button click_on].freeze
+        RESTRICT_ON_SEND = (STRICT_METHODS + CLICK_LINK_OR_BUTTON).freeze
+
+        def on_send(node)
+          return unless offense?(node)
+
+          add_offense(node, message: offense_message(node))
+        end
+
+        private
+
+        def offense?(node)
+          (style == :strict && !strict_method?(node)) ||
+            (style == :link_or_button && !link_or_button_method?(node))
+        end
+
+        def offense_message(node)
+          if style == :strict
+            format(MSG_STRICT, method: node.method_name)
+          elsif style == :link_or_button
+            format(MSG_CLICK_LINK_OR_BUTTON, method: node.method_name)
+          end
+        end
+
+        def strict_method?(node)
+          STRICT_METHODS.include?(node.method_name)
+        end
+
+        def link_or_button_method?(node)
+          CLICK_LINK_OR_BUTTON.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -18,15 +18,13 @@ module RuboCop
       # @example
       #   # bad
       #   expect(current_path).to eq('/callback')
+      #   expect(page.current_path).to eq('/callback')
       #
       #   # good
-      #   expect(page).to have_current_path('/callback')
+      #   expect(page).to have_current_path('/callback', ignore_query: true)
       #
-      #   # bad (does not support autocorrection)
-      #   expect(page.current_path).to match(variable)
-      #
-      #   # good
-      #   expect(page).to have_current_path('/callback')
+      #   # bad (does not support autocorrection when `match` with a variable)
+      #   expect(page).to match(variable)
       #
       class CurrentPathExpectation < ::RuboCop::Cop::Base
         extend AutoCorrector
@@ -95,7 +93,7 @@ module RuboCop
                            end
           corrector.replace(matcher_node.loc.selector, matcher_method)
           add_argument_parentheses(corrector, matcher_node.first_argument)
-          add_ignore_query_options(corrector, node)
+          add_ignore_query_options(corrector, node, matcher_node)
         end
 
         def convert_regexp_node_to_literal(corrector, matcher_node, regexp_node)
@@ -129,18 +127,13 @@ module RuboCop
         # `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)
+        # 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
-          return if %i[
-            regexp str dstr xstr
-          ].include?(expectation_last_child.type)
-
-          corrector.insert_after(
-            expectation_last_child,
-            ', ignore_query: true'
-          )
+          corrector.insert_after(expectation_last_child, ', ignore_query: true')
         end
       end
     end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Css selector parser.
+      # @api private
+      class CssAttributesParser
+        def initialize(selector)
+          @selector = selector
+          @state = :initial
+          @temp = ''
+          @results = {}
+          @bracket_count = 0
+        end
+
+        # @return [Array<String>]
+        def parse # rubocop:disable Metrics/MethodLength
+          @selector.chars do |char|
+            if char == '['
+              on_bracket_start
+            elsif char == ']'
+              on_bracket_end
+            elsif @state == :inside_attr
+              @temp += char
+            end
+          end
+          @results
+        end
+
+        private
+
+        def on_bracket_start
+          @bracket_count += 1
+          if @state == :initial
+            @state = :inside_attr
+          else
+            @temp += '['
+          end
+        end
+
+        def on_bracket_end
+          @bracket_count -= 1
+          if @bracket_count.zero?
+            @state = :initial
+            key, value = @temp.split('=')
+            @results[key] = normalize_value(value)
+            @temp.clear
+          else
+            @temp += ']'
+          end
+        end
+
+        # @param value [String]
+        # @return [Boolean, String]
+        # @example
+        #   normalize_value('true') # => true
+        #   normalize_value('false') # => false
+        #   normalize_value(nil) # => nil
+        #   normalize_value("foo") # => "'foo'"
+        def normalize_value(value)
+          case value
+          when 'true' then true
+          when 'false' then false
+          when nil then nil
+          else "'#{value.gsub(/"|'/, '')}'"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -55,15 +55,9 @@ module RuboCop
         #   attributes('a[foo-bar_baz]') # => {"foo-bar_baz=>nil}
         #   attributes('button[foo][bar=baz]') # => {"foo"=>nil, "bar"=>"'baz'"}
         #   attributes('table[foo=bar]') # => {"foo"=>"'bar'"}
+        #   attributes('[foo="bar[baz][qux]"]') # => {"foo"=>"'bar[baz][qux]'"}
         def attributes(selector)
-          # Extract the inner strings of attributes.
-          # For example, extract the following:
-          # 'button[foo][bar=baz]' => 'foo][bar=baz'
-          inside_attributes = selector.scan(/\[(.*)\]/).flatten.join
-          inside_attributes.split('][').to_h do |attr|
-            key, value = attr.split('=')
-            [key, normalize_value(value)]
-          end
+          CssAttributesParser.new(selector).parse
         end
 
         # @param selector [String]
@@ -89,22 +83,6 @@ module RuboCop
           normalize = selector.gsub(/(\\[>,+~]|\(.*\))/, '')
           normalize.match?(/[ >,+~]/)
         end
-
-        # @param value [String]
-        # @return [Boolean, String]
-        # @example
-        #   normalize_value('true') # => true
-        #   normalize_value('false') # => false
-        #   normalize_value(nil) # => nil
-        #   normalize_value("foo") # => "'foo'"
-        def normalize_value(value)
-          case value
-          when 'true' then true
-          when 'false' then false
-          when nil then nil
-          else "'#{value.gsub(/"|'/, '')}'"
-          end
-        end
       end
     end
   end

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

@@ -5,16 +5,7 @@ module RuboCop
     module Capybara
       # Enforces use of `have_no_*` or `not_to` for negated expectations.
       #
-      # @example EnforcedStyle: not_to (default)
-      #   # bad
-      #   expect(page).to have_no_selector
-      #   expect(page).to have_no_css('a')
-      #
-      #   # good
-      #   expect(page).not_to have_selector
-      #   expect(page).not_to have_css('a')
-      #
-      # @example EnforcedStyle: have_no
+      # @example EnforcedStyle: have_no (default)
       #   # bad
       #   expect(page).not_to have_selector
       #   expect(page).not_to have_css('a')
@@ -23,6 +14,15 @@ module RuboCop
       #   expect(page).to have_no_selector
       #   expect(page).to have_no_css('a')
       #
+      # @example EnforcedStyle: not_to
+      #   # bad
+      #   expect(page).to have_no_selector
+      #   expect(page).to have_no_css('a')
+      #
+      #   # good
+      #   expect(page).not_to have_selector
+      #   expect(page).not_to have_css('a')
+      #
       class NegationMatcher < ::RuboCop::Cop::Base
         extend AutoCorrector
         include ConfigurableEnforcedStyle

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for redundant `within find(...)` calls.
+      #
+      # @example
+      #   # bad
+      #   within find('foo.bar') do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   within 'foo.bar' do
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   within find_by_id('foo') do
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   within '#foo' do
+      #     # ...
+      #   end
+      #
+      class RedundantWithinFind < ::RuboCop::Cop::Base
+        extend AutoCorrector
+        MSG = 'Redundant `within %<method>s(...)` call detected.'
+        RESTRICT_ON_SEND = %i[within].freeze
+        FIND_METHODS = Set.new(%i[find find_by_id]).freeze
+
+        # @!method within_find(node)
+        def_node_matcher :within_find, <<~PATTERN
+          (send nil? :within
+            $(send nil? %FIND_METHODS ...))
+        PATTERN
+
+        def on_send(node)
+          within_find(node) do |find_node|
+            add_offense(find_node, message: msg(find_node)) do |corrector|
+              corrector.replace(find_node, replaced(find_node))
+            end
+          end
+        end
+
+        private
+
+        def msg(node)
+          format(MSG, method: node.method_name)
+        end
+
+        def replaced(node)
+          replaced = node.arguments.map(&:source).join(', ')
+          if node.method?(:find_by_id)
+            replaced.sub(/\A(["'])/, '\1#')
+          else
+            replaced
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Use `have_css` or `have_xpath` instead of `have_selector`.
+        #
+        # @example
+        #   # bad
+        #   expect(foo).to have_selector(:css, 'bar')
+        #
+        #   # good
+        #   expect(foo).to have_css('bar')
+        #
+        #   # bad
+        #   expect(foo).to have_selector(:xpath, 'bar')
+        #
+        #   # good
+        #   expect(foo).to have_xpath('bar')
+        #
+        # @example DefaultSelector: css (default)
+        #   # bad
+        #   expect(foo).to have_selector('bar')
+        #
+        #   # good
+        #   expect(foo).to have_css('bar')
+        #
+        # @example DefaultSelector: xpath
+        #   # bad
+        #   expect(foo).to have_selector('bar')
+        #
+        #   # good
+        #   expect(foo).to have_xpath('bar')
+        #
+        class HaveSelector < ::RuboCop::Cop::Base
+          extend AutoCorrector
+          include RangeHelp
+
+          MSG = 'Use `%<good>s` instead of `have_selector`.'
+          RESTRICT_ON_SEND = %i[have_selector].freeze
+          SELECTORS = %i[css xpath].freeze
+
+          def on_send(node)
+            argument = node.first_argument
+            on_select_with_type(node, argument) if argument.sym_type?
+            on_select_without_type(node) if %i[str dstr].include?(argument.type)
+          end
+
+          private
+
+          def on_select_with_type(node, type)
+            return unless SELECTORS.include?(type.value)
+
+            add_offense(node, message: message_typed(type)) do |corrector|
+              corrector.remove(deletion_range(type, node.arguments[1]))
+              corrector.replace(node.loc.selector, "have_#{type.value}")
+            end
+          end
+
+          def message_typed(type)
+            format(MSG, good: "have_#{type.value}")
+          end
+
+          def deletion_range(first_argument, second_argument)
+            range_between(first_argument.source_range.begin_pos,
+                          second_argument.source_range.begin_pos)
+          end
+
+          def on_select_without_type(node)
+            add_offense(node, message: message_untyped) do |corrector|
+              corrector.replace(node.loc.selector, "have_#{default_selector}")
+            end
+          end
+
+          def message_untyped
+            format(MSG, good: "have_#{default_selector}")
+          end
+
+          def default_selector
+            cop_config.fetch('DefaultSelector', 'css')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # A helper for `inflected` style
+        module InflectedHelper
+          extend NodePattern::Macros
+
+          EXPLICIT_MATCHER = %w[css selector style xpath].map do |suffix|
+            "matches_#{suffix}?".to_sym
+          end.freeze
+          MSG_INFLECTED = 'Prefer using `%<matcher_name>s` matcher over ' \
+                          '`%<predicate_name>s`.'
+
+          private
+
+          def check_inflected(node)
+            predicate_in_actual?(node) do |predicate, to, matcher|
+              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
+
+          # @!method predicate_in_actual?(node)
+          def_node_matcher :predicate_in_actual?, <<~PATTERN
+            (send
+              (send nil? :expect
+                {
+                  (block $(send !nil? #predicate? ...) ...)
+                  $(send !nil? #predicate? ...)
+                }
+              )
+              ${:to :to_not :not_to}
+              $#boolean_matcher?
+            )
+          PATTERN
+
+          # @!method be_bool?(node)
+          def_node_matcher :be_bool?, <<~PATTERN
+            (send nil? {:be :eq :eql :equal} {true false})
+          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
+
+          def boolean_matcher?(node)
+            if cop_config['Strict']
+              be_boolthy?(node)
+            else
+              be_bool?(node) || be_boolthy?(node)
+            end
+          end
+
+          def predicate?(sym)
+            EXPLICIT_MATCHER.include?(sym)
+          end
+
+          def message_inflected(predicate)
+            format(MSG_INFLECTED,
+                   predicate_name: predicate.method_name,
+                   matcher_name: to_predicate_matcher(predicate.method_name))
+          end
+
+          def to_predicate_matcher(name)
+            name.to_s.sub('matches_', 'match_')[0..-2]
+          end
+
+          def remove_predicate(corrector, predicate)
+            range = predicate.loc.dot.with(
+              end_pos: predicate.source_range.end_pos
+            )
+
+            corrector.remove(range)
+          end
+
+          def rewrite_matcher(corrector, predicate, matcher)
+            args = args_loc(predicate).source
+
+            corrector.replace(
+              matcher,
+              to_predicate_matcher(predicate.method_name) + args
+            )
+          end
+
+          def true?(to_symbol, matcher)
+            result = case matcher.method_name
+                     when :be, :eq
+                       matcher.first_argument.true_type?
+                     when :be_truthy, :a_truthy_value
+                       true
+                     when :be_falsey, :be_falsy, :a_falsey_value, :a_falsy_value
+                       false
+                     end
+            to_symbol == :to ? result : !result
+          end
+        end
+
+        # A helper for `explicit` style
+        module ExplicitHelper
+          extend NodePattern::Macros
+
+          MSG_EXPLICIT = 'Prefer using `%<predicate_name>s` over ' \
+                         '`%<matcher_name>s` matcher.'
+          BUILT_IN_MATCHERS = %w[
+            be_truthy be_falsey be_falsy
+            have_attributes have_received
+            be_between be_within
+          ].freeze
+          INFLECTED_MATCHER = %w[css selector style xpath].each.map do |suffix|
+            "match_#{suffix}"
+          end.freeze
+
+          private
+
+          def allowed_explicit_matchers
+            cop_config.fetch('AllowedExplicitMatchers', []) + BUILT_IN_MATCHERS
+          end
+
+          def check_explicit(node) # rubocop:disable Metrics/MethodLength
+            predicate_matcher?(node) do |actual, matcher|
+              add_offense(node,
+                          message: message_explicit(matcher)) do |corrector|
+                corrector_explicit(corrector, node, actual, matcher)
+              end
+            end
+          end
+
+          # @!method predicate_matcher?(node)
+          def_node_matcher :predicate_matcher?, <<~PATTERN
+            (send
+              (send nil? :expect $!nil?)
+              {:to :to_not :not_to}
+              {
+                $(send nil? #predicate_matcher_name? ...)
+                (block $(send nil? #predicate_matcher_name? ...) ...)
+              }
+            )
+          PATTERN
+
+          def predicate_matcher_name?(name)
+            name = name.to_s
+            return false if allowed_explicit_matchers.include?(name)
+
+            INFLECTED_MATCHER.include?(name)
+          end
+
+          def message_explicit(matcher)
+            format(MSG_EXPLICIT,
+                   predicate_name: to_predicate_method(matcher.method_name),
+                   matcher_name: matcher.method_name)
+          end
+
+          def corrector_explicit(corrector, to_node, actual, matcher)
+            replacement_matcher = replacement_matcher(to_node)
+            corrector.replace(matcher, replacement_matcher)
+            move_predicate(corrector, actual, matcher)
+            corrector.replace(to_node.loc.selector, 'to')
+          end
+
+          def move_predicate(corrector, actual, matcher)
+            predicate = to_predicate_method(matcher.method_name)
+            args = args_loc(matcher).source
+            corrector.insert_after(actual,
+                                   ".#{predicate}" + args)
+          end
+
+          def to_predicate_method(matcher)
+            "#{matcher.to_s.sub('match_', 'matches_')}?"
+          end
+
+          def replacement_matcher(node)
+            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]
+              'be_falsey'
+            end
+          end
+        end
+
+        # Prefer using predicate matcher over using predicate method directly.
+        #
+        # Capybara defines magic matchers for predicate methods.
+        # This cop recommends to use the predicate matcher instead of using
+        # predicate method directly.
+        #
+        # @example Strict: true, EnforcedStyle: inflected (default)
+        #   # bad
+        #   expect(foo.matches_css?(bar: 'baz')).to be_truthy
+        #   expect(foo.matches_selector?(bar: 'baz')).to be_truthy
+        #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+        #   expect(foo.matches_xpath?(bar: 'baz')).to be_truthy
+        #
+        #   # good
+        #   expect(foo).to match_css(bar: 'baz')
+        #   expect(foo).to match_selector(bar: 'baz')
+        #   expect(foo).to match_style(bar: 'baz')
+        #   expect(foo).to match_xpath(bar: 'baz')
+        #
+        #   # also good - It checks "true" strictly.
+        #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+        #
+        # @example Strict: false, EnforcedStyle: inflected
+        #   # bad
+        #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+        #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+        #
+        #   # good
+        #   expect(foo).to match_style(bar: 'baz')
+        #
+        # @example Strict: true, EnforcedStyle: explicit
+        #   # bad
+        #   expect(foo).to match_style(bar: 'baz')
+        #
+        #   # good - the above code is rewritten to it by this cop
+        #   expect(foo.matches_style?(bar: 'baz')).to be(true)
+        #
+        # @example Strict: false, EnforcedStyle: explicit
+        #   # bad
+        #   expect(foo).to match_style(bar: 'baz')
+        #
+        #   # good - the above code is rewritten to it by this cop
+        #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
+        #
+        class PredicateMatcher < ::RuboCop::Cop::Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+          include InflectedHelper
+          include ExplicitHelper
+
+          RESTRICT_ON_SEND = %i[to to_not not_to].freeze
+
+          def on_send(node)
+            if style == :inflected
+              check_inflected(node)
+            elsif style == :explicit
+              check_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.source_range.end_pos
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,15 +8,14 @@ module RuboCop
       # @example
       #   # bad
       #   find('#some-id')
-      #   find('[visible][id=some-id]')
+      #   find('[id=some-id]')
+      #   find(:css, '#some-id')
       #
       #   # good
       #   find_by_id('some-id')
-      #   find_by_id('some-id', visible: true)
       #
       class SpecificFinders < ::RuboCop::Cop::Base
         extend AutoCorrector
-
         include RangeHelp
 
         MSG = 'Prefer `find_by_id` over `find`.'
@@ -24,7 +23,7 @@ module RuboCop
 
         # @!method find_argument(node)
         def_node_matcher :find_argument, <<~PATTERN
-          (send _ :find (str $_) ...)
+          (send _ :find $(sym :css)? (str $_) ...)
         PATTERN
 
         # @!method class_options(node)
@@ -33,30 +32,30 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          find_argument(node) do |arg|
+          find_argument(node) do |sym, arg|
             next if CssSelector.pseudo_classes(arg).any?
             next if CssSelector.multiple_selectors?(arg)
 
-            on_attr(node, arg) if attribute?(arg)
-            on_id(node, arg) if CssSelector.id?(arg)
+            on_attr(node, sym, arg) if attribute?(arg)
+            on_id(node, sym, arg) if CssSelector.id?(arg)
           end
         end
 
         private
 
-        def on_attr(node, arg)
+        def on_attr(node, sym, arg)
           attrs = CssSelector.attributes(arg)
           return unless (id = attrs['id'])
           return if attrs['class']
 
-          register_offense(node, replaced_arguments(arg, id))
+          register_offense(node, sym, replaced_arguments(arg, id))
         end
 
-        def on_id(node, arg)
+        def on_id(node, sym, arg)
           return if CssSelector.attributes(arg).any?
 
           id = CssSelector.id(arg)
-          register_offense(node, "'#{id}'",
+          register_offense(node, sym, "'#{id}'",
                            CssSelector.classes(arg.sub("##{id}", '')))
         end
 
@@ -65,17 +64,22 @@ module RuboCop
             CapybaraHelp.common_attributes?(arg)
         end
 
-        def register_offense(node, id, classes = [])
+        def register_offense(node, sym, id, classes = [])
           add_offense(offense_range(node)) do |corrector|
             corrector.replace(node.loc.selector, 'find_by_id')
-            corrector.replace(node.first_argument,
-                              id.delete('\\'))
+            corrector.replace(node.first_argument, id.delete('\\'))
             unless classes.compact.empty?
               autocorrect_classes(corrector, node, classes)
             end
+            corrector.remove(deletion_range(node)) unless sym.empty?
           end
         end
 
+        def deletion_range(node)
+          range_between(node.first_argument.source_range.end_pos,
+                        node.arguments[1].source_range.end_pos)
+        end
+
         def autocorrect_classes(corrector, node, classes)
           if (options = class_options(node).first)
             append_options(classes, options)

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

@@ -42,6 +42,11 @@ module RuboCop
           (send nil? _ (str $_) ... )
         PATTERN
 
+        # @!method text_with_regexp?(node)
+        def_node_search :text_with_regexp?, <<-PATTERN
+          (pair (sym {:text :exact_text}) (regexp ...))
+        PATTERN
+
         def on_send(node)
           first_argument(node) do |arg|
             next unless (matcher = specific_matcher(arg))
@@ -61,6 +66,7 @@ module RuboCop
 
         def replaceable?(node, arg, matcher)
           replaceable_attributes?(arg) &&
+            !text_with_regexp?(node) &&
             CapybaraHelp.replaceable_option?(node, arg, matcher) &&
             CapybaraHelp.replaceable_pseudo_classes?(arg)
         end

data/lib/rubocop/cop/capybara_cops.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'capybara/rspec/have_selector'
+require_relative 'capybara/rspec/predicate_matcher'
+
+require_relative 'capybara/click_link_or_button_style'
 require_relative 'capybara/current_path_expectation'
 require_relative 'capybara/match_style'
 require_relative 'capybara/negation_matcher'
+require_relative 'capybara/redundant_within_find'
 require_relative 'capybara/specific_actions'
 require_relative 'capybara/specific_finders'
 require_relative 'capybara/specific_matcher'

data/lib/rubocop-capybara.rb

@@ -6,6 +6,7 @@ require 'yaml'
 require 'rubocop'
 
 require_relative 'rubocop/cop/capybara/mixin/capybara_help'
+require_relative 'rubocop/cop/capybara/mixin/css_attributes_parser'
 require_relative 'rubocop/cop/capybara/mixin/css_selector'
 
 require_relative 'rubocop/cop/capybara_cops'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-capybara
 version: !ruby/object:Gem::Version
-  version: 2.18.0
+  version: 2.20.0
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-21 00:00:00.000000000 Z
+date: 2024-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -43,11 +43,16 @@ files:
 - lib/rubocop/capybara/config_formatter.rb
 - lib/rubocop/capybara/description_extractor.rb
 - lib/rubocop/capybara/version.rb
+- lib/rubocop/cop/capybara/click_link_or_button_style.rb
 - lib/rubocop/cop/capybara/current_path_expectation.rb
 - lib/rubocop/cop/capybara/match_style.rb
 - lib/rubocop/cop/capybara/mixin/capybara_help.rb
+- lib/rubocop/cop/capybara/mixin/css_attributes_parser.rb
 - lib/rubocop/cop/capybara/mixin/css_selector.rb
 - lib/rubocop/cop/capybara/negation_matcher.rb
+- lib/rubocop/cop/capybara/redundant_within_find.rb
+- lib/rubocop/cop/capybara/rspec/have_selector.rb
+- lib/rubocop/cop/capybara/rspec/predicate_matcher.rb
 - lib/rubocop/cop/capybara/specific_actions.rb
 - lib/rubocop/cop/capybara/specific_finders.rb
 - lib/rubocop/cop/capybara/specific_matcher.rb
@@ -68,14 +73,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.5
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Code style checking for Capybara test files