Add new RSpec/Capybara/NegationMatcher cop

Resolve: rubocop#378

.rubocop.yml

@@ -115,6 +115,8 @@ RSpec/SubjectDeclaration:
   Enabled: true
 RSpec/VerifiedDoubleReference:
   Enabled: true
+RSpec/Capybara/NegationMatcher:
+  Enabled: true
 RSpec/Capybara/SpecificFinders:
   Enabled: true
 RSpec/Capybara/SpecificMatcher:

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 * Add `require_implicit` style to `RSpec/ImplicitSubject`. ([@r7kamura][])
 * Fix a false positive for `RSpec/Capybara/SpecificMatcher` when `have_css("a")` without attribute. ([@ydah][])
+* Add new `RSpec/Capybara/NegationMatcher` cop. ([@ydah][])
 
 ## 2.13.2 (2022-09-23)
 

config/default.yml

@@ -867,6 +867,16 @@ RSpec/Capybara/FeatureMethods:
   VersionChanged: '2.0'
   Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods
 
+RSpec/Capybara/NegationMatcher:
+  Description: Enforces use of `have_no_*` or `not_to` for negated expectations.
+  Enabled: pending
+  VersionAdded: '2.14'
+  EnforcedStyle: have_no
+  SupportedStyles:
+    - have_no
+    - not_to
+  Reference: https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/NegationMatcher
+
 RSpec/Capybara/SpecificFinders:
   Description: Checks if there is a more specific finder offered by Capybara.
   Enabled: pending

docs/modules/ROOT/pages/cops.adoc

@@ -95,6 +95,7 @@
 
 * xref:cops_rspec_capybara.adoc#rspeccapybara/currentpathexpectation[RSpec/Capybara/CurrentPathExpectation]
 * xref:cops_rspec_capybara.adoc#rspeccapybara/featuremethods[RSpec/Capybara/FeatureMethods]
+* xref:cops_rspec_capybara.adoc#rspeccapybara/negationmatcher[RSpec/Capybara/NegationMatcher]
 * xref:cops_rspec_capybara.adoc#rspeccapybara/specificfinders[RSpec/Capybara/SpecificFinders]
 * xref:cops_rspec_capybara.adoc#rspeccapybara/specificmatcher[RSpec/Capybara/SpecificMatcher]
 * xref:cops_rspec_capybara.adoc#rspeccapybara/visibilitymatcher[RSpec/Capybara/VisibilityMatcher]

docs/modules/ROOT/pages/cops_rspec_capybara.adoc

@@ -112,6 +112,62 @@ end
 
 * https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/FeatureMethods
 
+== RSpec/Capybara/NegationMatcher
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Pending
+| Yes
+| Yes
+| 2.14
+| -
+|===
+
+Enforces use of `have_no_*` or `not_to` for negated expectations.
+
+=== Examples
+
+==== EnforcedStyle: have_no (default)
+
+[source,ruby]
+----
+# 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')
+----
+
+==== EnforcedStyle: not_to
+
+[source,ruby]
+----
+# 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')
+----
+
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| EnforcedStyle
+| `have_no`
+| `have_no`, `not_to`
+|===
+
+=== References
+
+* https://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/Capybara/NegationMatcher
+
 == RSpec/Capybara/SpecificFinders
 
 |===

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Capybara
+        # Enforces use of `have_no_*` or `not_to` for negated expectations.
+        #
+        # @example EnforcedStyle: have_no (default)
+        #   # 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')
+        #
+        # @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 < Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+
+          MSG = 'Use `%<good>s` instead of `%<bad>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 = CAPYBARA_MATCHERS.map do |element|
+            "have_#{element}".to_sym
+          end.freeze
+          NEGATIVE_MATCHERS = CAPYBARA_MATCHERS.map do |element|
+            "have_no_#{element}".to_sym
+          end.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.map(&:inspect).join(' ')}}) ...)
+          PATTERN
+
+          # @!method have_no?(node)
+          def_node_matcher :have_no?, <<~PATTERN
+            (send ... :to
+              (send nil? {#{NEGATIVE_MATCHERS.map(&:inspect).join(' ')}}) ...)
+          PATTERN
+
+          def on_send(node)
+            return unless offense?(node.parent)
+
+            add_offense(offense_range(node),
+                        message: message(node)) do |corrector|
+              corrector.replace(node.parent.loc.selector, replaced_target)
+              corrector.replace(node.loc.selector, replaced_matcher(node))
+            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(node)
+            format(MSG,
+                   good: format_message(node.parent.loc.selector.source,
+                                        node.loc.selector.source),
+                   bad: format_message(replaced_target, replaced_matcher(node)))
+          end
+
+          def format_message(target, matcher)
+            "expect(...).#{target} #{matcher}"
+          end
+
+          def replaced_target
+            style == :have_no ? 'to' : 'not_to'
+          end
+
+          def replaced_matcher(node)
+            if style == :have_no
+              node.loc.selector.source.gsub('have_', 'have_no_')
+            else
+              node.loc.selector.source.gsub('_no', '')
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/rubocop/cop/rspec_cops.rb

@@ -2,6 +2,7 @@
 
 require_relative 'rspec/capybara/current_path_expectation'
 require_relative 'rspec/capybara/feature_methods'
+require_relative 'rspec/capybara/negation_matcher'
 require_relative 'rspec/capybara/specific_finders'
 require_relative 'rspec/capybara/specific_matcher'
 require_relative 'rspec/capybara/visibility_matcher'

spec/rubocop/cop/rspec/capybara/negation_matcher_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::Capybara::NegationMatcher, :config do
+  let(:cop_config) { { 'EnforcedStyle' => enforced_style } }
+
+  context 'with EnforcedStyle `have_no`' do
+    let(:enforced_style) { 'have_no' }
+
+    %i[selector css xpath text title current_path link button
+       field checked_field unchecked_field select table
+       sibling ancestor].each do |matcher|
+      it 'registers an offense when using ' \
+        '`expect(...).not_to have_#{matcher}`' do
+        expect_offense(<<~RUBY, matcher: matcher)
+          expect(page).not_to have_#{matcher}
+                       ^^^^^^^^^^^^^{matcher} Use `expect(...).not_to have_#{matcher}` instead of `expect(...).to have_no_#{matcher}`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(page).to have_no_#{matcher}
+        RUBY
+      end
+
+      it 'does not register an offense when using ' \
+        '`expect(...).to have_no_#{matcher}`' do
+        expect_no_offenses(<<~RUBY)
+          expect(page).to have_no_selector
+        RUBY
+      end
+    end
+  end
+
+  context 'with EnforcedStyle `not_to`' do
+    let(:enforced_style) { 'not_to' }
+
+    %i[selector css xpath text title current_path link button
+       field checked_field unchecked_field select table
+       sibling ancestor].each do |matcher|
+      it 'registers an offense when using ' \
+        '`expect(...).to have_no_#{matcher}`' do
+        expect_offense(<<~RUBY, matcher: matcher)
+          expect(page).to have_no_#{matcher}
+                       ^^^^^^^^^^^^{matcher} Use `expect(...).to have_no_#{matcher}` instead of `expect(...).not_to have_#{matcher}`.
+        RUBY
+
+        expect_correction(<<~RUBY)
+          expect(page).not_to have_#{matcher}
+        RUBY
+      end
+
+      it 'does not register an offense when using ' \
+        '`expect(...).not_to have_#{matcher}`' do
+        expect_no_offenses(<<~RUBY)
+          expect(page).not_to have_selector
+        RUBY
+      end
+    end
+  end
+end