rubocop-capybara 2.18.0 → 2.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb7f795cc80f072b94781f2339e781cccf9922ad2303c09111c0e34a4af264f8
-  data.tar.gz: d2ae47b522208177b7c93338973c8a144dfbccca2f817f0797b531f8c89e50b9
+  metadata.gz: 5af741b67ec2d02d9e27e688d553e5e1c8cbb04c845f5d9771b480b291b1d805
+  data.tar.gz: cbef51994ffa79af69a8a7aac9aabf69ccc307b3c2c104eae2a3a4c635467d26
 SHA512:
-  metadata.gz: 36b58f29500840c7dc34c2c2ed55856ff08cdd7ca41822209a9388204948903be89cf13c3065da7cfed3e8332f3433b3293087c8de1cf1266f093fadef2fa69d
-  data.tar.gz: 5b961abac7ae8dd46708ec9649718a23596bde9e45bcc48f7d9e818c2a116d5fda3de0653cf3aa8e56d11ed11ebcb94e24ef49ee0653e739a26d43d2383c2152
+  metadata.gz: 98bcff699a8ee323a24118f26b412ed8e4d26754df9ee82eab0b107f1b96cb2a0ad7ba898925fde7683501244f1474231bd53591f450e6080321e0bd83245257
+  data.tar.gz: 4194b54f6b12d4b168122c59fbfa18ec210e92cb4d20207665787ae870a3a92a240938818e187889f239e5ce29244db5c612c368bf761ee68f65f1617f72092f

data/CHANGELOG.md

@@ -2,10 +2,19 @@
 
 ## Edge (Unreleased)
 
+## 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,23 @@
 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 click button or link style.
+  Enabled: pending
+  VersionAdded: '2.19'
+  EnforcedStyle: strict
+  SupportedStyles:
+    - strict
+    - link_or_button
+  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
@@ -56,3 +66,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.19.0'
     end
   end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for click button or link style.
+      #
+      # @example EnforcedStyle: strict (default)
+      #   # bad
+      #   click_link_or_button('foo')
+      #   click_on('foo')
+      #
+      #   # good
+      #   click_link('foo')
+      #   click_button('foo')
+      #
+      # @example EnforcedStyle: link_or_button
+      #   # bad
+      #   click_link('foo')
+      #   click_button('foo')
+      #
+      #   # good
+      #   click_link_or_button('foo')
+      #   click_on('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/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 argument.str_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.arguments[0].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_cops.rb

@@ -1,5 +1,9 @@
 # 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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-capybara
 version: !ruby/object:Gem::Version
-  version: 2.18.0
+  version: 2.19.0
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-21 00:00:00.000000000 Z
+date: 2023-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -43,11 +43,14 @@ 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_selector.rb
 - lib/rubocop/cop/capybara/negation_matcher.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 +71,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.3.7
 signing_key:
 specification_version: 4
 summary: Code style checking for Capybara test files