rubocop-capybara 2.22.0 → 2.23.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Enforces use of `have_no_*` or `not_to` for negated expectations.
+        #
+        # @example EnforcedStyle: have_no (default)
+        #   # bad
+        #   expect(page).not_to have_selector 'a'
+        #   expect(page).not_to have_css('a')
+        #
+        #   # good
+        #   expect(page).to have_no_selector 'a'
+        #   expect(page).to have_no_css('a')
+        #
+        # @example EnforcedStyle: not_to
+        #   # bad
+        #   expect(page).to have_no_selector 'a'
+        #   expect(page).to have_no_css('a')
+        #
+        #   # good
+        #   expect(page).not_to have_selector 'a'
+        #   expect(page).not_to have_css('a')
+        #
+        class NegationMatcher < ::RuboCop::Cop::Base
+          extend AutoCorrector
+          include ConfigurableEnforcedStyle
+          include CapybaraHelp
+
+          MSG = 'Use `expect(...).%<runner>s %<matcher>s`.'
+          RESTRICT_ON_SEND = (POSITIVE_MATCHERS + NEGATIVE_MATCHERS).freeze
+
+          # @!method not_to?(node)
+          def_node_matcher :not_to?, <<~PATTERN
+            (send ... {:not_to :to_not}
+              (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)
+
+            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)
+            node.arguments? &&
+              ((style == :have_no && not_to?(node.parent)) ||
+              (style == :not_to && have_no?(node.parent)))
+          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'
+            else
+              # :nocov:
+              :noop
+              # :nocov:
+            end
+          end
+
+          def replaced_matcher(matcher)
+            case style
+            when :have_no
+              matcher.sub('have_', 'have_no_')
+            when :not_to
+              matcher.sub('have_no_', 'have_')
+            else
+              # :nocov:
+              :noop
+              # :nocov:
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Do not allow negative matchers to be used immediately after `visit`.
+        #
+        # @example
+        #   # bad
+        #   visit foo_path
+        #   expect(page).to have_no_link('bar')
+        #   expect(page).to have_css('a')
+        #
+        #   # good
+        #   visit foo_path
+        #   expect(page).to have_css('a')
+        #   expect(page).to have_no_link('bar')
+        #
+        #   # bad
+        #   visit foo_path
+        #   expect(page).not_to have_link('bar')
+        #   expect(page).to have_css('a')
+        #
+        #   # good
+        #   visit foo_path
+        #   expect(page).to have_css('a')
+        #   expect(page).not_to have_link('bar')
+        #
+        class NegationMatcherAfterVisit < ::RuboCop::Cop::Base
+          include CapybaraHelp
+
+          MSG = 'Do not use negation matcher immediately after visit.'
+          RESTRICT_ON_SEND = %i[visit].freeze
+
+          # @!method negation_matcher?(node)
+          def_node_matcher :negation_matcher?, <<~PATTERN
+            {
+              (send (send nil? :expect _) :to (send nil? %NEGATIVE_MATCHERS ...))
+              (send (send nil? :expect _) :not_to (send nil? %POSITIVE_MATCHERS ...))
+            }
+          PATTERN
+
+          def on_send(node)
+            negation_matcher?(node.right_sibling) do
+              add_offense(node.right_sibling)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # 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(with: '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
+
+          # @!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))
+              next if CssSelector.multiple_selectors?(arg)
+              next unless replaceable?(node, arg, matcher)
+
+              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 replaceable?(node, arg, matcher)
+            replaceable_attributes?(arg) &&
+              !text_with_regexp?(node) &&
+              CapybaraHelp.replaceable_option?(node, arg, matcher) &&
+              CapybaraHelp.replaceable_pseudo_classes?(arg)
+          end
+
+          def replaceable_attributes?(selector)
+            CapybaraHelp.replaceable_attributes?(
+              CssSelector.attributes(selector)
+            )
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # 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 at: https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all
+        #
+        # @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
+      end
+    end
+  end
+end

data/lib/rubocop/cop/capybara_cops.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'capybara/rspec/current_path_expectation'
+require_relative 'capybara/rspec/have_content'
 require_relative 'capybara/rspec/have_selector'
+require_relative 'capybara/rspec/match_style'
+require_relative 'capybara/rspec/negation_matcher'
+require_relative 'capybara/rspec/negation_matcher_after_visit'
 require_relative 'capybara/rspec/predicate_matcher'
+require_relative 'capybara/rspec/specific_matcher'
+require_relative 'capybara/rspec/visibility_matcher'
 
 require_relative 'capybara/ambiguous_click'
+require_relative 'capybara/assert_style'
 require_relative 'capybara/click_link_or_button_style'
-require_relative 'capybara/current_path_expectation'
 require_relative 'capybara/find_all_first'
-require_relative 'capybara/match_style'
-require_relative 'capybara/negation_matcher'
-require_relative 'capybara/negation_matcher_after_visit'
 require_relative 'capybara/redundant_within_find'
 require_relative 'capybara/specific_actions'
 require_relative 'capybara/specific_finders'
-require_relative 'capybara/specific_matcher'
-require_relative 'capybara/visibility_matcher'

data/lib/rubocop-capybara.rb

@@ -6,6 +6,7 @@ require 'yaml'
 require 'rubocop'
 
 require_relative 'rubocop/capybara/plugin'
+require_relative 'rubocop/capybara/version'
 
 require_relative 'rubocop/cop/capybara/mixin/capybara_help'
 require_relative 'rubocop/cop/capybara/mixin/css_attributes_parser'
@@ -16,7 +17,7 @@ require_relative 'rubocop/cop/capybara_cops'
 RuboCop::Cop::Style::TrailingCommaInArguments.singleton_class.prepend(
   Module.new do
     def autocorrect_incompatible_with
-      super.push(RuboCop::Cop::Capybara::CurrentPathExpectation)
+      super.push(RuboCop::Cop::Capybara::RSpec::CurrentPathExpectation)
     end
   end
 )

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-capybara
 version: !ruby/object:Gem::Version
-  version: 2.22.0
+  version: 2.23.0
 platform: ruby
 authors:
 - Yudai Takada
 bindir: bin
 cert_chain: []
-date: 2025-03-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -29,20 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: '1.81'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.72'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: '1.81'
 description: |
   Code style checking for Capybara test files (RSpec, Cucumber, Minitest).
   A plugin for the RuboCop code style enforcing & linting tool.
@@ -57,6 +51,7 @@ files:
 - MIT-LICENSE.md
 - README.md
 - config/default.yml
+- config/obsoletion.yml
 - lib/rubocop-capybara.rb
 - lib/rubocop/capybara/config_formatter.rb
 - lib/rubocop/capybara/cop/generator.rb
@@ -64,22 +59,24 @@ files:
 - lib/rubocop/capybara/plugin.rb
 - lib/rubocop/capybara/version.rb
 - lib/rubocop/cop/capybara/ambiguous_click.rb
+- lib/rubocop/cop/capybara/assert_style.rb
 - lib/rubocop/cop/capybara/click_link_or_button_style.rb
-- lib/rubocop/cop/capybara/current_path_expectation.rb
 - lib/rubocop/cop/capybara/find_all_first.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/negation_matcher_after_visit.rb
 - lib/rubocop/cop/capybara/redundant_within_find.rb
+- lib/rubocop/cop/capybara/rspec/current_path_expectation.rb
+- lib/rubocop/cop/capybara/rspec/have_content.rb
 - lib/rubocop/cop/capybara/rspec/have_selector.rb
+- lib/rubocop/cop/capybara/rspec/match_style.rb
+- lib/rubocop/cop/capybara/rspec/negation_matcher.rb
+- lib/rubocop/cop/capybara/rspec/negation_matcher_after_visit.rb
 - lib/rubocop/cop/capybara/rspec/predicate_matcher.rb
+- lib/rubocop/cop/capybara/rspec/specific_matcher.rb
+- lib/rubocop/cop/capybara/rspec/visibility_matcher.rb
 - lib/rubocop/cop/capybara/specific_actions.rb
 - lib/rubocop/cop/capybara/specific_finders.rb
-- lib/rubocop/cop/capybara/specific_matcher.rb
-- lib/rubocop/cop/capybara/visibility_matcher.rb
 - lib/rubocop/cop/capybara_cops.rb
 homepage: https://github.com/rubocop/rubocop-capybara
 licenses:
@@ -103,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Code style checking for Capybara test files
 test_files: []

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    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')
-      #   expect(page.current_path).to eq('/callback')
-      #
-      #   # good
-      #   expect(page).to have_current_path('/callback', ignore_query: true)
-      #
-      #   # bad (does not support autocorrection when `match` with a variable)
-      #   expect(page).to match(variable)
-      #
-      class CurrentPathExpectation < ::RuboCop::Cop::Base
-        extend AutoCorrector
-        include RangeHelp
-
-        MSG = 'Do not set an RSpec expectation on `current_path` in ' \
-              'Capybara feature specs - instead, use the ' \
-              '`have_current_path` matcher on `page`'
-
-        RESTRICT_ON_SEND = %i[expect].freeze
-
-        # @!method expectation_set_on_current_path(node)
-        def_node_matcher :expectation_set_on_current_path, <<~PATTERN
-          (send nil? :expect (send {(send nil? :page) nil?} :current_path))
-        PATTERN
-
-        # Supported matchers: eq(...) / match(/regexp/) / match('regexp')
-        # @!method as_is_matcher(node)
-        def_node_matcher :as_is_matcher, <<~PATTERN
-          (send
-            #expectation_set_on_current_path ${:to :to_not :not_to}
-            ${(send nil? :eq ...) (send nil? :match (regexp ...))})
-        PATTERN
-
-        # @!method regexp_node_matcher(node)
-        def_node_matcher :regexp_node_matcher, <<~PATTERN
-          (send
-            #expectation_set_on_current_path ${:to :to_not :not_to}
-            $(send nil? :match ${str dstr xstr}))
-        PATTERN
-
-        def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArguments]
-        end
-
-        def on_send(node)
-          expectation_set_on_current_path(node) do
-            add_offense(node.loc.selector) do |corrector|
-              next unless node.chained?
-
-              autocorrect(corrector, node)
-            end
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          as_is_matcher(node.parent) do |to_sym, matcher_node|
-            rewrite_expectation(corrector, node, to_sym, matcher_node)
-          end
-
-          regexp_node_matcher(node.parent) do |to_sym, matcher_node, regexp|
-            rewrite_expectation(corrector, node, to_sym, matcher_node)
-            convert_regexp_node_to_literal(corrector, matcher_node, regexp)
-          end
-        end
-
-        def rewrite_expectation(corrector, node, to_symbol, matcher_node)
-          corrector.replace(node.first_argument, 'page')
-          corrector.replace(node.parent.loc.selector, 'to')
-          matcher_method = if to_symbol == :to
-                             'have_current_path'
-                           else
-                             'have_no_current_path'
-                           end
-          corrector.replace(matcher_node.loc.selector, matcher_method)
-          add_argument_parentheses(corrector, matcher_node.first_argument)
-          add_ignore_query_options(corrector, node, matcher_node)
-        end
-
-        def convert_regexp_node_to_literal(corrector, matcher_node, regexp_node)
-          str_node = matcher_node.first_argument
-          regexp_expr = regexp_node_to_regexp_expr(regexp_node)
-          corrector.replace(str_node, regexp_expr)
-        end
-
-        def regexp_node_to_regexp_expr(regexp_node)
-          if regexp_node.xstr_type?
-            "/\#{`#{regexp_node.value.value}`}/"
-          else
-            Regexp.new(regexp_node.value).inspect
-          end
-        end
-
-        def add_argument_parentheses(corrector, arg_node)
-          return unless method_call_with_no_parentheses?(arg_node)
-
-          first_argument_range = range_with_surrounding_space(
-            arg_node.first_argument.source_range, side: :left
-          )
-          corrector.insert_before(first_argument_range, '(')
-          corrector.insert_after(arg_node.last_argument, ')')
-        end
-
-        def method_call_with_no_parentheses?(arg_node)
-          arg_node.send_type? && arg_node.arguments? && !arg_node.parenthesized?
-        end
-
-        # `have_current_path` with no options will include the querystring
-        # while `page.current_path` does not.
-        # This ensures the option `ignore_query: true` is added
-        # except when `match` matcher.
-        def add_ignore_query_options(corrector, node, matcher_node)
-          return if matcher_node.method?(:match)
-
-          expectation_node = node.parent.last_argument
-          expectation_last_child = expectation_node.children.last
-          corrector.insert_after(expectation_last_child, ', ignore_query: true')
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    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 < ::RuboCop::Cop::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
-    end
-  end
-end