rubocop-rspec 2.17.1 → 2.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5f767597141ddcf9b2e28f8f02490b63d2e0e4e2a5804a81383af2c4ae15332
-  data.tar.gz: 8f55d65178e33b86fb6b685499876e116dfe2665c1e8da201b462721982dc49c
+  metadata.gz: 5b2ef643f2d262910bba4db8e0e6a722b96d0cb6424d04d4261326155176f321
+  data.tar.gz: 29ae9b634075bd3dc11d44969fb00a7542aad3302f3a1aa360a2637e3875a3bc
 SHA512:
-  metadata.gz: 4a42691283f03313b47cd59c36d040f1bd10b7da16bed5f1b96d80bdf65fdc592ad1df94c2288c9e157f8c6a101e028500b3126a40657eb87c2c1345675d1957
-  data.tar.gz: f3803001a19e2871f96f18ce9053bb43551298affb4478d20bd3c30edcff7aa814690b5e1f6b978da77d53d17910372202360f307cc52962ce5dd4c600f34dca
+  metadata.gz: b14f91843dcbc6cd8abfca82a8f21244991aacb79d09a92e975c1eb6d36e554adc44bd1d8b14d2d014fed60b6383f1e102f5142c4a771532be1b60db47c01df1
+  data.tar.gz: 0626b43df05da5b5f386d18be195d2aaa14347a7f70cd99d2d1731e9f9107536c8a0076897b78d9f2f4e69cdeb2a79bc0caaab488a6bee822ea08add9b083fe9

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Master (Unreleased)
 
+## 2.18.1 (2023-01-19)
+
+- Add `rubocop-capybara` version constraint to prevent sudden cop enabling when it hits 3.0. ([@pirj])
+
+## 2.18.0 (2023-01-16)
+
+- Extract Capybara cops to a separate repository, [`rubocop-capybara`](https://github.com/rubocop/rubocop-capybara). The `rubocop-capybara` repository is a dependency of `rubocop-rspec` and the Capybara cops are aliased (`RSpec/Capybara/Foo` == `Capybara/Foo`) until v3.0 is released, so the change will be invisible to users until then. ([@pirj])
+
 ## 2.17.1 (2023-01-16)
 
 - Fix a false negative for `RSpec/Pending` when using skipped in metadata is multiline string. ([@ydah])

data/config/obsoletion.yml

@@ -12,3 +12,12 @@ changed_parameters:
     parameters: IgnoredPatterns
     alternative: AllowedPatterns
     severity: warning
+
+renamed:
+  RSpec/Capybara/CurrentPathExpectation: Capybara/CurrentPathExpectation
+  RSpec/Capybara/MatchStyle: Capybara/MatchStyle
+  RSpec/Capybara/NegationMatcher: Capybara/NegationMatcher
+  RSpec/Capybara/SpecificActions: Capybara/SpecificActions
+  RSpec/Capybara/SpecificFinders: Capybara/SpecificFinders
+  RSpec/Capybara/SpecificMatcher: Capybara/SpecificMatcher
+  RSpec/Capybara/VisibilityMatcher: Capybara/VisibilityMatcher

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

@@ -4,121 +4,35 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # 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')
-        #
-        #   # good
-        #   expect(page).to have_current_path('/callback')
-        #
-        #   # bad (does not support autocorrection)
-        #   expect(page.current_path).to match(variable)
-        #
-        #   # good
-        #   expect(page).to have_current_path('/callback')
-        #
-        class CurrentPathExpectation < ::RuboCop::Cop::Base
-          extend AutoCorrector
-
-          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_str_matcher(node)
-          def_node_matcher :regexp_str_matcher, <<-PATTERN
-            (send
-              #expectation_set_on_current_path ${:to :to_not :not_to}
-              $(send nil? :match (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_str_matcher(node.parent) do |to_sym, matcher_node, regexp|
-              rewrite_expectation(corrector, node, to_sym, matcher_node)
-              convert_regexp_str_to_literal(corrector, matcher_node, regexp)
-            end
-          end
-
-          def rewrite_expectation(corrector, node, to_symbol, matcher_node)
-            current_path_node = node.first_argument
-            corrector.replace(current_path_node, 'page')
-            corrector.replace(node.parent.loc.selector, 'to')
-            matcher_method = if to_symbol == :to
-                               'have_current_path'
-                             else
-                               'have_no_current_path'
-                             end
-            corrector.replace(matcher_node.loc.selector, matcher_method)
-            add_ignore_query_options(corrector, node)
-          end
-
-          def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str)
-            str_node = matcher_node.first_argument
-            regexp_expr = Regexp.new(regexp_str).inspect
-            corrector.replace(str_node, regexp_expr)
-          end
-
-          # `have_current_path` with no options will include the querystring
-          # while `page.current_path` does not.
-          # This ensures the option `ignore_query: true` is added
-          # except when the expectation is a regexp or string
-          def add_ignore_query_options(corrector, node)
-            expectation_node = node.parent.last_argument
-            expectation_last_child = expectation_node.children.last
-            return if %i[regexp str].include?(expectation_last_child.type)
-
-            corrector.insert_after(
-              expectation_last_child,
-              ', ignore_query: true'
-            )
-          end
-        end
+        # @!parse
+        #   # 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')
+        #   #
+        #   #   # good
+        #   #   expect(page).to have_current_path('/callback')
+        #   #
+        #   #   # bad (does not support autocorrection)
+        #   #   expect(page.current_path).to match(variable)
+        #   #
+        #   #   # good
+        #   #   expect(page).to have_current_path('/callback')
+        #   #
+        #   class CurrentPathExpectation < ::RuboCop::Cop::Base; end
+        CurrentPathExpectation =
+          ::RuboCop::Cop::Capybara::CurrentPathExpectation
       end
     end
   end

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

@@ -4,56 +4,34 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks for usage of deprecated style methods.
-        #
-        # @example when using `assert_style`
-        #   # bad
-        #   page.find(:css, '#first').assert_style(display: 'block')
-        #
-        #   # good
-        #   page.find(:css, '#first').assert_matches_style(display: 'block')
-        #
-        # @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 < Base
-          extend AutoCorrector
-
-          MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-          RESTRICT_ON_SEND = %i[assert_style has_style? have_style].freeze
-          PREFERRED_METHOD = {
-            'assert_style' => 'assert_matches_style',
-            'has_style?' => 'matches_style?',
-            'have_style' => 'match_style'
-          }.freeze
-
-          def on_send(node)
-            method_node = node.loc.selector
-            add_offense(method_node) do |corrector|
-              corrector.replace(method_node,
-                                PREFERRED_METHOD[method_node.source])
-            end
-          end
-
-          private
-
-          def message(node)
-            format(MSG, good: PREFERRED_METHOD[node.source], bad: node.source)
-          end
-        end
+        # @!parse
+        #   # Checks for usage of deprecated style methods.
+        #   #
+        #   # @example when using `assert_style`
+        #   #   # bad
+        #   #   page.find(:css, '#first').assert_style(display: 'block')
+        #   #
+        #   #   # good
+        #   #   page.find(:css, '#first').assert_matches_style(display: 'block')
+        #   #
+        #   # @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; end
+        MatchStyle = ::RuboCop::Cop::Capybara::MatchStyle
       end
     end
   end

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

@@ -4,102 +4,29 @@ module RuboCop
   module Cop
     module RSpec
       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
-        #   # bad
-        #   expect(page).not_to have_selector
-        #   expect(page).not_to have_css('a')
-        #
-        #   # good
-        #   expect(page).to have_no_selector
-        #   expect(page).to have_no_css('a')
-        #
-        class NegationMatcher < ::RuboCop::Cop::Base
-          extend AutoCorrector
-          include ConfigurableEnforcedStyle
-
-          MSG = 'Use `expect(...).%<runner>s %<matcher>s`.'
-          CAPYBARA_MATCHERS = %w[
-            selector css xpath text title current_path link button
-            field checked_field unchecked_field select table
-            sibling ancestor
-          ].freeze
-          POSITIVE_MATCHERS =
-            Set.new(CAPYBARA_MATCHERS) { |element| :"have_#{element}" }.freeze
-          NEGATIVE_MATCHERS =
-            Set.new(CAPYBARA_MATCHERS) { |element| :"have_no_#{element}" }
-              .freeze
-          RESTRICT_ON_SEND = (POSITIVE_MATCHERS + NEGATIVE_MATCHERS).freeze
-
-          # @!method not_to?(node)
-          def_node_matcher :not_to?, <<~PATTERN
-            (send ... :not_to
-              (send nil? %POSITIVE_MATCHERS ...))
-          PATTERN
-
-          # @!method have_no?(node)
-          def_node_matcher :have_no?, <<~PATTERN
-            (send ... :to
-              (send nil? %NEGATIVE_MATCHERS ...))
-          PATTERN
-
-          def on_send(node)
-            return unless offense?(node.parent)
-
-            matcher = node.method_name.to_s
-            add_offense(offense_range(node),
-                        message: message(matcher)) do |corrector|
-              corrector.replace(node.parent.loc.selector, replaced_runner)
-              corrector.replace(node.loc.selector,
-                                replaced_matcher(matcher))
-            end
-          end
-
-          private
-
-          def offense?(node)
-            (style == :have_no && not_to?(node)) ||
-              (style == :not_to && have_no?(node))
-          end
-
-          def offense_range(node)
-            node.parent.loc.selector.with(end_pos: node.loc.selector.end_pos)
-          end
-
-          def message(matcher)
-            format(MSG,
-                   runner: replaced_runner,
-                   matcher: replaced_matcher(matcher))
-          end
-
-          def replaced_runner
-            case style
-            when :have_no
-              'to'
-            when :not_to
-              'not_to'
-            end
-          end
-
-          def replaced_matcher(matcher)
-            case style
-            when :have_no
-              matcher.sub('have_', 'have_no_')
-            when :not_to
-              matcher.sub('have_no_', 'have_')
-            end
-          end
-        end
+        # @!parse
+        #   # 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
+        #   #   # bad
+        #   #   expect(page).not_to have_selector
+        #   #   expect(page).not_to have_css('a')
+        #   #
+        #   #   # good
+        #   #   expect(page).to have_no_selector
+        #   #   expect(page).to have_no_css('a')
+        #   #
+        #   class NegationMatcher < ::RuboCop::Cop::Base; end
+        NegationMatcher = ::RuboCop::Cop::Capybara::NegationMatcher
       end
     end
   end

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

@@ -4,81 +4,25 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks for there is a more specific actions offered by Capybara.
-        #
-        # @example
-        #
-        #   # bad
-        #   find('a').click
-        #   find('button.cls').click
-        #   find('a', exact_text: 'foo').click
-        #   find('div button').click
-        #
-        #   # good
-        #   click_link
-        #   click_button(class: 'cls')
-        #   click_link(exact_text: 'foo')
-        #   find('div').click_button
-        #
-        class SpecificActions < ::RuboCop::Cop::Base
-          MSG = "Prefer `%<good_action>s` over `find('%<selector>s').click`."
-          RESTRICT_ON_SEND = %i[click].freeze
-          SPECIFIC_ACTION = {
-            'button' => 'button',
-            'a' => 'link'
-          }.freeze
-
-          # @!method click_on_selector(node)
-          def_node_matcher :click_on_selector, <<-PATTERN
-            (send _ :find (str $_) ...)
-          PATTERN
-
-          def on_send(node)
-            click_on_selector(node.receiver) do |arg|
-              next unless supported_selector?(arg)
-              # Always check the last selector in the case of multiple selectors
-              # separated by whitespace.
-              # because the `.click` is executed on the element to
-              # which the last selector points.
-              next unless (selector = last_selector(arg))
-              next unless (action = specific_action(selector))
-              next unless CapybaraHelp.specific_option?(node.receiver, arg,
-                                                        action)
-              next unless CapybaraHelp.specific_pseudo_classes?(arg)
-
-              range = offense_range(node, node.receiver)
-              add_offense(range, message: message(action, selector))
-            end
-          end
-
-          private
-
-          def specific_action(selector)
-            SPECIFIC_ACTION[last_selector(selector)]
-          end
-
-          def supported_selector?(selector)
-            !selector.match?(/[>,+~]/)
-          end
-
-          def last_selector(arg)
-            arg.split.last[/^\w+/, 0]
-          end
-
-          def offense_range(node, receiver)
-            receiver.loc.selector.with(end_pos: node.loc.expression.end_pos)
-          end
-
-          def message(action, selector)
-            format(MSG,
-                   good_action: good_action(action),
-                   selector: selector)
-          end
-
-          def good_action(action)
-            "click_#{action}"
-          end
-        end
+        # @!parse
+        #   # Checks for there is a more specific actions offered by Capybara.
+        #   #
+        #   # @example
+        #   #
+        #   #   # bad
+        #   #   find('a').click
+        #   #   find('button.cls').click
+        #   #   find('a', exact_text: 'foo').click
+        #   #   find('div button').click
+        #   #
+        #   #   # good
+        #   #   click_link
+        #   #   click_button(class: 'cls')
+        #   #   click_link(exact_text: 'foo')
+        #   #   find('div').click_button
+        #   #
+        #   class SpecificActions < ::RuboCop::Cop::Base; end
+        SpecificActions = ::RuboCop::Cop::Capybara::SpecificActions
       end
     end
   end

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

@@ -4,89 +4,20 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks if there is a more specific finder offered by Capybara.
-        #
-        # @example
-        #   # bad
-        #   find('#some-id')
-        #   find('[visible][id=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` over `find`.'
-          RESTRICT_ON_SEND = %i[find].freeze
-
-          # @!method find_argument(node)
-          def_node_matcher :find_argument, <<~PATTERN
-            (send _ :find (str $_) ...)
-          PATTERN
-
-          def on_send(node)
-            find_argument(node) do |arg|
-              next if CssSelector.multiple_selectors?(arg)
-
-              on_attr(node, arg) if attribute?(arg)
-              on_id(node, arg) if CssSelector.id?(arg)
-            end
-          end
-
-          private
-
-          def on_attr(node, arg)
-            return unless (id = CssSelector.attributes(arg)['id'])
-
-            register_offense(node, replaced_arguments(arg, id))
-          end
-
-          def on_id(node, arg)
-            register_offense(node, "'#{arg.to_s.delete('#')}'")
-          end
-
-          def attribute?(arg)
-            CssSelector.attribute?(arg) &&
-              CssSelector.common_attributes?(arg)
-          end
-
-          def register_offense(node, arg_replacement)
-            add_offense(offense_range(node)) do |corrector|
-              corrector.replace(node.loc.selector, 'find_by_id')
-              corrector.replace(node.first_argument.loc.expression,
-                                arg_replacement)
-            end
-          end
-
-          def replaced_arguments(arg, id)
-            options = to_options(CssSelector.attributes(arg))
-            options.empty? ? id : "#{id}, #{options}"
-          end
-
-          def to_options(attrs)
-            attrs.each.map do |key, value|
-              next if key == 'id'
-
-              "#{key}: #{value}"
-            end.compact.join(', ')
-          end
-
-          def offense_range(node)
-            range_between(node.loc.selector.begin_pos, end_pos(node))
-          end
-
-          def end_pos(node)
-            if node.loc.end
-              node.loc.end.end_pos
-            else
-              node.loc.expression.end_pos
-            end
-          end
-        end
+        # @!parse
+        #   # Checks if there is a more specific finder offered by Capybara.
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   find('#some-id')
+        #   #   find('[visible][id=some-id]')
+        #   #
+        #   #   # good
+        #   #   find_by_id('some-id')
+        #   #   find_by_id('some-id', visible: true)
+        #   #
+        #   class SpecificFinders < ::RuboCop::Cop::Base; end
+        SpecificFinders = ::RuboCop::Cop::Capybara::SpecificFinders
       end
     end
   end

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

@@ -4,75 +4,31 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks for there is a more specific matcher offered by Capybara.
-        #
-        # @example
-        #
-        #   # bad
-        #   expect(page).to have_selector('button')
-        #   expect(page).to have_no_selector('button.cls')
-        #   expect(page).to have_css('button')
-        #   expect(page).to have_no_css('a.cls', href: 'http://example.com')
-        #   expect(page).to have_css('table.cls')
-        #   expect(page).to have_css('select')
-        #   expect(page).to have_css('input', exact_text: 'foo')
-        #
-        #   # good
-        #   expect(page).to have_button
-        #   expect(page).to have_no_button(class: 'cls')
-        #   expect(page).to have_button
-        #   expect(page).to have_no_link('foo', class: 'cls', href: 'http://example.com')
-        #   expect(page).to have_table(class: 'cls')
-        #   expect(page).to have_select
-        #   expect(page).to have_field('foo')
-        #
-        class SpecificMatcher < ::RuboCop::Cop::Base
-          MSG = 'Prefer `%<good_matcher>s` over `%<bad_matcher>s`.'
-          RESTRICT_ON_SEND = %i[have_selector have_no_selector have_css
-                                have_no_css].freeze
-          SPECIFIC_MATCHER = {
-            'button' => 'button',
-            'a' => 'link',
-            'table' => 'table',
-            'select' => 'select',
-            'input' => 'field'
-          }.freeze
-
-          # @!method first_argument(node)
-          def_node_matcher :first_argument, <<-PATTERN
-            (send nil? _ (str $_) ... )
-          PATTERN
-
-          def on_send(node)
-            first_argument(node) do |arg|
-              next unless (matcher = specific_matcher(arg))
-              next if CssSelector.multiple_selectors?(arg)
-              next unless CapybaraHelp.specific_option?(node, arg, matcher)
-              next unless CapybaraHelp.specific_pseudo_classes?(arg)
-
-              add_offense(node, message: message(node, matcher))
-            end
-          end
-
-          private
-
-          def specific_matcher(arg)
-            splitted_arg = arg[/^\w+/, 0]
-            SPECIFIC_MATCHER[splitted_arg]
-          end
-
-          def message(node, matcher)
-            format(MSG,
-                   good_matcher: good_matcher(node, matcher),
-                   bad_matcher: node.method_name)
-          end
-
-          def good_matcher(node, matcher)
-            node.method_name
-              .to_s
-              .gsub(/selector|css/, matcher.to_s)
-          end
-        end
+        # @!parse
+        #   # Checks for there is a more specific matcher offered by Capybara.
+        #   #
+        #   # @example
+        #   #
+        #   #   # bad
+        #   #   expect(page).to have_selector('button')
+        #   #   expect(page).to have_no_selector('button.cls')
+        #   #   expect(page).to have_css('button')
+        #   #   expect(page).to have_no_css('a.cls', href: 'http://example.com')
+        #   #   expect(page).to have_css('table.cls')
+        #   #   expect(page).to have_css('select')
+        #   #   expect(page).to have_css('input', exact_text: 'foo')
+        #   #
+        #   #   # good
+        #   #   expect(page).to have_button
+        #   #   expect(page).to have_no_button(class: 'cls')
+        #   #   expect(page).to have_button
+        #   #   expect(page).to have_no_link('foo', class: 'cls', href: 'http://example.com')
+        #   #   expect(page).to have_table(class: 'cls')
+        #   #   expect(page).to have_select
+        #   #   expect(page).to have_field('foo')
+        #   #
+        #   class SpecificMatcher < ::RuboCop::Cop::Base; end
+        SpecificMatcher = ::RuboCop::Cop::Capybara::SpecificMatcher
       end
     end
   end

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

@@ -4,69 +4,32 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks for boolean visibility in Capybara finders.
-        #
-        # Capybara lets you find elements that match a certain visibility using
-        # the `:visible` option. `:visible` accepts both boolean and symbols as
-        # values, however using booleans can have unwanted effects. `visible:
-        # false` does not find just invisible elements, but both visible and
-        # invisible elements. For expressiveness and clarity, use one of the
-        # symbol values, `:all`, `:hidden` or `:visible`.
-        # Read more in
-        # https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation].
-        #
-        # @example
-        #   # bad
-        #   expect(page).to have_selector('.foo', visible: false)
-        #   expect(page).to have_css('.foo', visible: true)
-        #   expect(page).to have_link('my link', visible: false)
-        #
-        #   # good
-        #   expect(page).to have_selector('.foo', visible: :visible)
-        #   expect(page).to have_css('.foo', visible: :all)
-        #   expect(page).to have_link('my link', visible: :hidden)
-        #
-        class VisibilityMatcher < ::RuboCop::Cop::Base
-          MSG_FALSE = 'Use `:all` or `:hidden` instead of `false`.'
-          MSG_TRUE = 'Use `:visible` instead of `true`.'
-          CAPYBARA_MATCHER_METHODS = %w[
-            button
-            checked_field
-            css
-            field
-            link
-            select
-            selector
-            table
-            unchecked_field
-            xpath
-          ].flat_map do |element|
-            ["have_#{element}".to_sym, "have_no_#{element}".to_sym]
-          end
-
-          RESTRICT_ON_SEND = CAPYBARA_MATCHER_METHODS
-
-          # @!method visible_true?(node)
-          def_node_matcher :visible_true?, <<~PATTERN
-            (send nil? #capybara_matcher? ... (hash <$(pair (sym :visible) true) ...>))
-          PATTERN
-
-          # @!method visible_false?(node)
-          def_node_matcher :visible_false?, <<~PATTERN
-            (send nil? #capybara_matcher? ... (hash <$(pair (sym :visible) false) ...>))
-          PATTERN
-
-          def on_send(node)
-            visible_false?(node) { |arg| add_offense(arg, message: MSG_FALSE) }
-            visible_true?(node) { |arg| add_offense(arg, message: MSG_TRUE) }
-          end
-
-          private
-
-          def capybara_matcher?(method_name)
-            CAPYBARA_MATCHER_METHODS.include? method_name
-          end
-        end
+        # @!parse
+        #   # Checks for boolean visibility in Capybara finders.
+        #   #
+        #   # Capybara lets you find elements that match a certain visibility
+        #   # using the `:visible` option. `:visible` accepts both boolean and
+        #   # symbols as values, however using booleans can have unwanted
+        #   # effects. `visible: false` does not find just invisible elements,
+        #   # but both visible and invisible elements. For expressiveness and
+        #   # clarity, use one of the # symbol values, `:all`, `:hidden` or
+        #   # `:visible`.
+        #   # Read more in
+        #   # https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation].
+        #   #
+        #   # @example
+        #   #   # bad
+        #   #   expect(page).to have_selector('.foo', visible: false)
+        #   #   expect(page).to have_css('.foo', visible: true)
+        #   #   expect(page).to have_link('my link', visible: false)
+        #   #
+        #   #   # good
+        #   #   expect(page).to have_selector('.foo', visible: :visible)
+        #   #   expect(page).to have_css('.foo', visible: :all)
+        #   #   expect(page).to have_link('my link', visible: :hidden)
+        #   #
+        #   class VisibilityMatcher < ::RuboCop::Cop::Base; end
+        VisibilityMatcher = ::RuboCop::Cop::Capybara::VisibilityMatcher
       end
     end
   end

data/lib/rubocop/rspec/config_formatter.rb

@@ -8,6 +8,15 @@ module RuboCop
     class ConfigFormatter
       EXTENSION_ROOT_DEPARTMENT = %r{^(RSpec/)}.freeze
       SUBDEPARTMENTS = %(RSpec/Capybara RSpec/FactoryBot RSpec/Rails)
+      EXTRACTED_COPS = %(
+        RSpec/Capybara/CurrentPathExpectation
+        RSpec/Capybara/MatchStyle
+        RSpec/Capybara/NegationMatcher
+        RSpec/Capybara/SpecificActions
+        RSpec/Capybara/SpecificFinders
+        RSpec/Capybara/SpecificMatcher
+        RSpec/Capybara/VisibilityMatcher
+      )
       AMENDMENTS = %(Metrics/BlockLength)
       COP_DOC_BASE_URL = 'https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/'
 
@@ -29,6 +38,7 @@ module RuboCop
       def unified_config
         cops.each_with_object(config.dup) do |cop, unified|
           next if SUBDEPARTMENTS.include?(cop) || AMENDMENTS.include?(cop)
+          next if EXTRACTED_COPS.include?(cop)
 
           replace_nil(unified[cop])
           unified[cop].merge!(descriptions.fetch(cop))

data/lib/rubocop/rspec/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module RSpec
     # Version information for the RSpec RuboCop plugin.
     module Version
-      STRING = '2.17.1'
+      STRING = '2.18.1'
     end
   end
 end

data/lib/rubocop-rspec.rb

@@ -4,6 +4,7 @@ require 'pathname'
 require 'yaml'
 
 require 'rubocop'
+require 'rubocop-capybara'
 
 require_relative 'rubocop/rspec'
 require_relative 'rubocop/rspec/inject'
@@ -17,8 +18,6 @@ require_relative 'rubocop/rspec/language'
 
 require_relative 'rubocop/rspec/factory_bot/language'
 
-require_relative 'rubocop/cop/rspec/mixin/capybara_help'
-require_relative 'rubocop/cop/rspec/mixin/css_selector'
 require_relative 'rubocop/cop/rspec/mixin/final_end_location'
 require_relative 'rubocop/cop/rspec/mixin/inside_example_group'
 require_relative 'rubocop/cop/rspec/mixin/metadata'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rspec
 version: !ruby/object:Gem::Version
-  version: 2.17.1
+  version: 2.18.1
 platform: ruby
 authors:
 - John Backus
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -26,6 +26,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.33'
+- !ruby/object:Gem::Dependency
+  name: rubocop-capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.17'
 description: |2
       Code style checking for RSpec files.
       A plugin for the RuboCop code style enforcing & linting tool.
@@ -116,9 +130,7 @@ files:
 - lib/rubocop/cop/rspec/message_expectation.rb
 - lib/rubocop/cop/rspec/message_spies.rb
 - lib/rubocop/cop/rspec/missing_example_group_argument.rb
-- lib/rubocop/cop/rspec/mixin/capybara_help.rb
 - lib/rubocop/cop/rspec/mixin/comments_help.rb
-- lib/rubocop/cop/rspec/mixin/css_selector.rb
 - lib/rubocop/cop/rspec/mixin/empty_line_separation.rb
 - lib/rubocop/cop/rspec/mixin/final_end_location.rb
 - lib/rubocop/cop/rspec/mixin/inside_example_group.rb

data/lib/rubocop/cop/rspec/mixin/capybara_help.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Help methods for capybara.
-      module CapybaraHelp
-        module_function
-
-        # @param node [RuboCop::AST::SendNode]
-        # @param locator [String]
-        # @param element [String]
-        # @return [Boolean]
-        def specific_option?(node, locator, element)
-          attrs = CssSelector.attributes(locator).keys
-          return false unless replaceable_element?(node, element, attrs)
-
-          attrs.all? do |attr|
-            CssSelector.specific_options?(element, attr)
-          end
-        end
-
-        # @param locator [String]
-        # @return [Boolean]
-        def specific_pseudo_classes?(locator)
-          CssSelector.pseudo_classes(locator).all? do |pseudo_class|
-            replaceable_pseudo_class?(pseudo_class, locator)
-          end
-        end
-
-        # @param pseudo_class [String]
-        # @param locator [String]
-        # @return [Boolean]
-        def replaceable_pseudo_class?(pseudo_class, locator)
-          return false unless CssSelector.specific_pesudo_classes?(pseudo_class)
-
-          case pseudo_class
-          when 'not()' then replaceable_pseudo_class_not?(locator)
-          else true
-          end
-        end
-
-        # @param locator [String]
-        # @return [Boolean]
-        def replaceable_pseudo_class_not?(locator)
-          locator.scan(/not\(.*?\)/).all? do |negation|
-            CssSelector.attributes(negation).values.all? do |v|
-              v.is_a?(TrueClass) || v.is_a?(FalseClass)
-            end
-          end
-        end
-
-        # @param node [RuboCop::AST::SendNode]
-        # @param element [String]
-        # @param attrs [Array<String>]
-        # @return [Boolean]
-        def replaceable_element?(node, element, attrs)
-          case element
-          when 'link' then replaceable_to_link?(node, attrs)
-          else true
-          end
-        end
-
-        # @param node [RuboCop::AST::SendNode]
-        # @param attrs [Array<String>]
-        # @return [Boolean]
-        def replaceable_to_link?(node, attrs)
-          include_option?(node, :href) || attrs.include?('href')
-        end
-
-        # @param node [RuboCop::AST::SendNode]
-        # @param option [Symbol]
-        # @return [Boolean]
-        def include_option?(node, option)
-          node.each_descendant(:sym).find { |opt| opt.value == option }
-        end
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module RSpec
-      # Helps parsing css selector.
-      module CssSelector
-        COMMON_OPTIONS = %w[
-          above below left_of right_of near count minimum maximum between text
-          id class style visible obscured exact exact_text normalize_ws match
-          wait filter_set focused
-        ].freeze
-        SPECIFIC_OPTIONS = {
-          'button' => (
-            COMMON_OPTIONS + %w[disabled name value title type]
-          ).freeze,
-          'link' => (
-            COMMON_OPTIONS + %w[href alt title download]
-          ).freeze,
-          'table' => (
-            COMMON_OPTIONS + %w[
-              caption with_cols cols with_rows rows
-            ]
-          ).freeze,
-          'select' => (
-            COMMON_OPTIONS + %w[
-              disabled name placeholder options enabled_options
-              disabled_options selected with_selected multiple with_options
-            ]
-          ).freeze,
-          'field' => (
-            COMMON_OPTIONS + %w[
-              checked unchecked disabled valid name placeholder
-              validation_message readonly with type multiple
-            ]
-          ).freeze
-        }.freeze
-        SPECIFIC_PSEUDO_CLASSES = %w[
-          not() disabled enabled checked unchecked
-        ].freeze
-
-        module_function
-
-        # @param element [String]
-        # @param attribute [String]
-        # @return [Boolean]
-        # @example
-        #   specific_pesudo_classes?('button', 'name') # => true
-        #   specific_pesudo_classes?('link', 'invalid') # => false
-        def specific_options?(element, attribute)
-          SPECIFIC_OPTIONS.fetch(element, []).include?(attribute)
-        end
-
-        # @param pseudo_class [String]
-        # @return [Boolean]
-        # @example
-        #   specific_pesudo_classes?('disabled') # => true
-        #   specific_pesudo_classes?('first-of-type') # => false
-        def specific_pesudo_classes?(pseudo_class)
-          SPECIFIC_PSEUDO_CLASSES.include?(pseudo_class)
-        end
-
-        # @param selector [String]
-        # @return [Boolean]
-        # @example
-        #   id?('#some-id') # => true
-        #   id?('.some-class') # => false
-        def id?(selector)
-          selector.start_with?('#')
-        end
-
-        # @param selector [String]
-        # @return [Boolean]
-        # @example
-        #   attribute?('[attribute]') # => true
-        #   attribute?('attribute') # => false
-        def attribute?(selector)
-          selector.start_with?('[')
-        end
-
-        # @param selector [String]
-        # @return [Array<String>]
-        # @example
-        #   attributes('a[foo-bar_baz]') # => {"foo-bar_baz=>true}
-        #   attributes('button[foo][bar]') # => {"foo"=>true, "bar"=>true}
-        #   attributes('table[foo=bar]') # => {"foo"=>"'bar'"}
-        def attributes(selector)
-          selector.scan(/\[(.*?)\]/).flatten.to_h do |attr|
-            key, value = attr.split('=')
-            [key, normalize_value(value)]
-          end
-        end
-
-        # @param selector [String]
-        # @return [Boolean]
-        # @example
-        #   common_attributes?('a[focused]') # => true
-        #   common_attributes?('button[focused][visible]') # => true
-        #   common_attributes?('table[id=some-id]') # => true
-        #   common_attributes?('h1[invalid]') # => false
-        def common_attributes?(selector)
-          attributes(selector).keys.difference(COMMON_OPTIONS).none?
-        end
-
-        # @param selector [String]
-        # @return [Array<String>]
-        # @example
-        #   pseudo_classes('button:not([disabled])') # => ['not()']
-        #   pseudo_classes('a:enabled:not([valid])') # => ['enabled', 'not()']
-        def pseudo_classes(selector)
-          # Attributes must be excluded or else the colon in the `href`s URL
-          # will also be picked up as pseudo classes.
-          # "a:not([href='http://example.com']):enabled" => "a:not():enabled"
-          ignored_attribute = selector.gsub(/\[.*?\]/, '')
-          # "a:not():enabled" => ["not()", "enabled"]
-          ignored_attribute.scan(/:([^:]*)/).flatten
-        end
-
-        # @param selector [String]
-        # @return [Boolean]
-        # @example
-        #   multiple_selectors?('a.cls b#id') # => true
-        #   multiple_selectors?('a.cls') # => false
-        def multiple_selectors?(selector)
-          selector.match?(/[ >,+~]/)
-        end
-
-        # @param value [String]
-        # @return [Boolean, String]
-        # @example
-        #   normalize_value('true') # => true
-        #   normalize_value('false') # => false
-        #   normalize_value(nil) # => false
-        #   normalize_value("foo") # => "'foo'"
-        def normalize_value(value)
-          case value
-          when 'true' then true
-          when 'false' then false
-          when nil then true
-          else "'#{value}'"
-          end
-        end
-      end
-    end
-  end
-end