rubocop-capybara 2.23.0 → 3.1.0

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

@@ -8,6 +8,8 @@ module RuboCop
       module CssSelector
         module_function
 
+        ID_PATTERN = /\A#((?:[\w-]|\\[.>,+~])+)(?:\.|\z)/.freeze
+
         # @param selector [String]
         # @return [String]
         # @example
@@ -15,9 +17,7 @@ module RuboCop
         #   id('.some-cls') # => nil
         #   id('#some-id.cls') # => some-id
         def id(selector)
-          return unless id?(selector)
-
-          selector.delete('#').gsub(selector.scan(/[^\\]([>,+~.].*)/).join, '')
+          selector[ID_PATTERN, 1]
         end
 
         # @param selector [String]
@@ -26,18 +26,21 @@ module RuboCop
         #   id?('#some-id') # => true
         #   id?('.some-cls') # => false
         def id?(selector)
-          selector.start_with?('#')
+          !id(selector).nil?
         end
 
         # @param selector [String]
-        # @return [Array<String>]
+        # @return [Hash<String, String, Boolean, nil>]
         # @example
         #   classes('#some-id') # => []
         #   classes('.some-cls') # => ['some-cls']
         #   classes('#some-id.some-cls') # => ['some-cls']
         #   classes('#some-id.cls1.cls2') # => ['cls1', 'cls2']
+        #   classes('.some-cls\.with-dot') # => ['some-cls.with-dot']
         def classes(selector)
-          selector.scan(/\.([\w-]*)/).flatten
+          selector.scan(/(?<!\\)\.((?:\\.|[\w-])+)/).flatten.map do |class_name|
+            class_name.gsub('\\.', '.')
+          end
         end
 
         # @param selector [String]
@@ -50,12 +53,12 @@ module RuboCop
         end
 
         # @param selector [String]
-        # @return [Array<String>]
+        # @return [Hash<String, String, Boolean, nil>]
         # @example
         #   attributes('a[foo-bar_baz]') # => {"foo-bar_baz=>nil}
-        #   attributes('button[foo][bar=baz]') # => {"foo"=>nil, "bar"=>"'baz'"}
-        #   attributes('table[foo=bar]') # => {"foo"=>"'bar'"}
-        #   attributes('[foo="bar[baz][qux]"]') # => {"foo"=>"'bar[baz][qux]'"}
+        #   attributes('button[foo][bar=baz]') # => {"foo"=>nil, "bar"=>"baz"}
+        #   attributes('table[foo=bar]') # => {"foo"=>"bar"}
+        #   attributes('[foo="bar[baz][qux]"]') # => {"foo"=>"bar[baz][qux]"}
         def attributes(selector)
           CssAttributesParser.new(selector).parse
         end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Classification of Capybara's public query methods.
+      # @api private
+      module QueryMethods
+        BUILT_IN_SELECTORS = %i[
+          button checkbox css datalist_input datalist_option element field
+          fieldset file_field fillable_field frame id label link link_or_button
+          option radio_button select table table_row xpath
+        ].freeze
+
+        # Each entry contains the query type and its selector. `:selector`
+        # means the selector is an argument; nil means it is not applicable.
+        METHODS = begin
+          methods = {
+            find: %i[finder selector],
+            ancestor: %i[finder selector],
+            sibling: %i[finder selector],
+            find_button: %i[finder button],
+            find_by_id: %i[finder id],
+            find_field: %i[finder field],
+            find_link: %i[finder link],
+            within: %i[finder selector]
+          }
+          %i[all find_all first].each do |name|
+            methods[name] = %i[collection selector]
+          end
+
+          %w[
+            ancestor button checked_field css element field link select
+            selector sibling table unchecked_field xpath
+          ].each do |selector|
+            kind = case selector
+                   when 'ancestor', 'sibling' then :selector
+                   when 'checked_field', 'unchecked_field' then :field
+                   else selector.to_sym
+                   end
+            prefixes = %w[assert assert_no refute has has_no have have_no]
+            prefixes += %w[must_have wont_have] unless selector == 'element'
+            prefixes.each do |prefix|
+              name = "#{prefix}_#{selector}"
+              name += '?' if prefix.start_with?('has')
+              methods[name.to_sym] = [:selector, kind]
+            end
+          end
+
+          %w[css selector xpath].each do |selector|
+            %W[
+              assert_matches_#{selector} assert_not_matches_#{selector}
+              refute_matches_#{selector} matches_#{selector}?
+              not_matches_#{selector}? match_#{selector} not_match_#{selector}
+              must_match_#{selector} wont_match_#{selector}
+            ].each { |name| methods[name.to_sym] = [:match, selector.to_sym] }
+          end
+
+          %w[text content].each do |kind|
+            %W[
+              assert_#{kind} assert_no_#{kind} refute_#{kind}
+              has_#{kind}? has_no_#{kind}? have_#{kind} have_no_#{kind}
+              must_have_#{kind} wont_have_#{kind}
+            ].each { |name| methods[name.to_sym] = [:text, nil] }
+          end
+
+          %i[
+            attach_file check choose click_button click_link
+            click_link_or_button click_on fill_in select uncheck unselect
+          ].each { |name| methods[name] = [:action, nil] }
+
+          %w[assert have must_have].product(%w[all any none]) do |prefix, count|
+            methods[:"#{prefix}_#{count}_of_selectors"] = %i[grouped selector]
+          end
+
+          methods.transform_values(&:freeze).freeze
+        end
+        private_constant :METHODS, :BUILT_IN_SELECTORS
+
+        module_function
+
+        # @param types [Array<Symbol>]
+        # @return [Array<Symbol>]
+        # @example
+        #   names(:collection) # => [:all, :find_all, :first]
+        def names(*types)
+          METHODS.filter_map { |name, (type, _)| name if types.include?(type) }
+        end
+
+        # @param method_name [Symbol]
+        # @return [Symbol, nil]
+        # @example
+        #   type(:find) # => :finder
+        #   type(:unknown) # => nil
+        def type(method_name)
+          METHODS[method_name]&.first
+        end
+
+        # @param method_name [Symbol]
+        # @return [Symbol, nil]
+        # @example
+        #   selector(:find_button) # => :button
+        #   selector(:find) # => :selector
+        #   selector(:have_text) # => nil
+        def selector(method_name)
+          METHODS[method_name]&.last
+        end
+
+        # @param selector [Symbol]
+        # @return [Boolean]
+        # @example
+        #   built_in_selector?(:css) # => true
+        #   built_in_selector?(:custom) # => false
+        def built_in_selector?(selector)
+          BUILT_IN_SELECTORS.include?(selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Shared visibility query checks and offense handling.
+      # @api private
+      module Visibility
+        extend RuboCop::AST::NodePattern::Macros
+
+        # @!method custom_filters?(node)
+        def_node_matcher :custom_filters?, <<~PATTERN
+          (hash <{(pair (sym :filter_set) _) (pair !sym _) kwsplat} ...>)
+        PATTERN
+
+        private
+
+        def supported_visibility_query?(node, options)
+          return false if options.braces? || custom_filters?(options)
+          return true if QueryMethods.selector(node.method_name) != :selector
+
+          QueryMethods.built_in_selector?(query_selector(node))
+        end
+
+        def query_selector(node)
+          selector = node.first_argument
+          return selector.value if selector&.sym_type?
+
+          positional = node.arguments.reject do |arg|
+            arg.type?(:hash, :block_pass)
+          end
+          return if positional.length > 1 && !selector.str_type?
+
+          cop_config['DefaultSelector'].to_s.to_sym
+        end
+
+        def check_visibility(pair)
+          if pair.value.false_type?
+            return add_offense(pair, message: CapybaraHelp::VISIBILITY_FALSE_MESSAGE)
+          end
+
+          add_offense(
+            pair, message: CapybaraHelp::VISIBILITY_TRUE_MESSAGE
+          ) do |corrector|
+            next if block_given? && !yield
+
+            corrector.replace(pair.value, ':visible')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks that modal handling methods are called with a block.
+      #
+      # @example
+      #   # bad
+      #   accept_confirm
+      #   page.accept_prompt(with: 'answer')
+      #
+      #   # good
+      #   accept_confirm { click_button 'Delete' }
+      #   page.accept_prompt(with: 'answer', &trigger_modal)
+      #
+      class ModalMethodWithoutBlock < RuboCop::Cop::Base
+        MSG = 'Call `%<method>s` with a block.'
+        RESTRICT_ON_SEND = %i[
+          accept_alert
+          accept_confirm
+          accept_prompt
+          dismiss_confirm
+          dismiss_prompt
+        ].freeze
+
+        def on_send(node)
+          return if node.block_literal? || node.block_argument?
+          return if node.last_argument&.forwarded_args_type?
+
+          add_offense(node, message: format(MSG, method: node.method_name))
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Enforces use of `Element#[]` instead of `native.attribute`.
+      #
+      # Only calls on Capybara finder chains are checked.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because attribute values may
+      #   differ between the driver API and Capybara's `Element#[]`.
+      #
+      # @example
+      #   # bad
+      #   find('.item').native.attribute(:id)
+      #   page.find('.item').native.attribute('aria-label')
+      #
+      #   # good
+      #   find('.item')[:id]
+      #   page.find('.item')['aria-label']
+      #
+      class NativeAttribute < RuboCop::Cop::Base
+        extend AutoCorrector
+        include CapybaraHelp
+
+        MSG = 'Use `Element#[]` instead of driver-specific `native.attribute`.'
+        RESTRICT_ON_SEND = %i[attribute].freeze
+
+        # @!method native_attribute(node)
+        def_node_matcher :native_attribute, <<~PATTERN
+          (call
+            $(call #element_finder? :native)
+            :attribute
+            $({str sym} _))
+        PATTERN
+
+        # @!method element_finder?(node)
+        def_node_matcher :element_finder?, <<~PATTERN
+          {#capybara_receiver?
+           (call #capybara_receiver?
+             {:ancestor :find :find_button :find_by_id
+              :find_field :find_link :first :sibling} ...)
+           (any_block #element_finder? ...)
+           (begin #element_finder?)}
+        PATTERN
+
+        def on_send(node)
+          native_attribute(node) do |native, attribute|
+            next unless native.receiver
+
+            add_offense(node) do |corrector|
+              next if attribute.str_type? && attribute.heredoc?
+
+              correct_attribute(corrector, node, native, attribute)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def correct_attribute(corrector, node, native, attribute)
+          range = node.source_range.with(begin_pos: native.loc.dot.begin_pos)
+          return if processed_source.comments.any? do |comment|
+            range.contains?(comment.source_range)
+          end
+
+          safe_navigation = native.csend_type? && node.csend_type?
+          template = safe_navigation ? '&.[](%s)' : '[%s]'
+          corrector.replace(range, format(template, attribute.source))
+        end
+      end
+    end
+  end
+end

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

@@ -22,13 +22,13 @@ module RuboCop
       #   end
       #
       #   # good
-      #   within '#foo' do
+      #   within :id, 'foo' do
       #     # ...
       #   end
       #
-      class RedundantWithinFind < ::RuboCop::Cop::Base
-        include CssSelector
+      class RedundantWithinFind < RuboCop::Cop::Base
         extend AutoCorrector
+
         MSG = 'Redundant `within %<method>s(...)` call detected.'
         RESTRICT_ON_SEND = %i[within].freeze
         FIND_METHODS = Set.new(%i[find find_by_id]).freeze
@@ -41,8 +41,10 @@ module RuboCop
 
         def on_send(node)
           within_find(node) do |find_node|
+            replacement = replaced(find_node)
+
             add_offense(find_node, message: msg(find_node)) do |corrector|
-              corrector.replace(find_node, replaced(find_node))
+              corrector.replace(find_node, replacement) if replacement
             end
           end
         end
@@ -54,24 +56,11 @@ module RuboCop
         end
 
         def replaced(node)
-          unless node.method?(:find_by_id)
-            return node.arguments.map(&:source).join(', ')
-          end
-
-          if node.first_argument.str_type?
-            build_escaped_selector(node.first_argument, node)
-          else
-            node.arguments.map(&:source).join(', ')
-              .sub(/\A(["'])/, '\1#')
-          end
-        end
-
-        def build_escaped_selector(first_arg, node)
-          quote = first_arg.source[0]
-          escaped_id = CssSelector.css_escape(first_arg.value, quote)
-          rest_args = node.arguments.drop(1).map(&:source)
+          return unless node.first_argument
+          return if node.arguments.any?(&:block_pass_type?)
 
-          ["#{quote}##{escaped_id}#{quote}", *rest_args].join(', ')
+          args = node.arguments.map(&:source).join(', ')
+          node.method?(:find_by_id) ? ":id, #{args}" : args
         end
       end
     end

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

@@ -25,9 +25,9 @@ module RuboCop
         #   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)
+        #   expect(current_path).to match(variable)
         #
-        class CurrentPathExpectation < ::RuboCop::Cop::Base
+        class CurrentPathExpectation < RuboCop::Cop::Base
           extend AutoCorrector
           include RangeHelp
 
@@ -79,8 +79,11 @@ module RuboCop
             end
 
             regexp_node_matcher(node.parent) do |to_sym, matcher_node, regexp|
+              regexp_expr = regexp_node_to_regexp_expr(regexp)
+              next unless regexp_expr
+
               rewrite_expectation(corrector, node, to_sym, matcher_node)
-              convert_regexp_node_to_literal(corrector, matcher_node, regexp)
+              corrector.replace(matcher_node.first_argument, regexp_expr)
             end
           end
 
@@ -94,22 +97,19 @@ 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, 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)
+            add_ignore_query_options(corrector, node)
           end
 
           def regexp_node_to_regexp_expr(regexp_node)
             if regexp_node.xstr_type?
               "/\#{`#{regexp_node.value.value}`}/"
             else
+              return if regexp_node.value.match?(/#[{@$]/)
+
               Regexp.new(regexp_node.value).inspect
             end
+          rescue RegexpError
+            nil
           end
 
           def add_argument_parentheses(corrector, arg_node)
@@ -129,11 +129,8 @@ 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 `match` matcher.
-          def add_ignore_query_options(corrector, node, matcher_node)
-            return if matcher_node.method?(:match)
-
+          # This ensures the option `ignore_query: true` is added.
+          def add_ignore_query_options(corrector, node)
             expectation_node = node.parent.last_argument
             expectation_last_child = expectation_node.children.last
             corrector.insert_after(expectation_last_child,

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      module RSpec
+        # Checks expectations on `current_url` that bypass Capybara's waiting.
+        #
+        # `have_current_path` can match full URLs and waits for navigation.
+        # A regexp needs `url: true` so it matches the full URL, not just the
+        # path. Autocorrection is unsafe because URL parsing and waiting change
+        # comparison behavior.
+        # Dynamic `match` patterns and `include`, `start_with`, and `end_with`
+        # are reported without autocorrection.
+        #
+        # @example
+        #   # bad
+        #   expect(page.current_url).to eq('https://example.com/login')
+        #   expect(current_url).to match(%r{/login})
+        #   expect(current_url).to match('login')
+        #   expect(page.current_url).to include('/login')
+        #
+        #   # good
+        #   expect(page).to have_current_path('https://example.com/login')
+        #   expect(page).to have_current_path(%r{/login}, url: true)
+        #   expect(page).to have_current_path(/login/, url: true)
+        #
+        class CurrentUrlExpectation < RuboCop::Cop::Base
+          extend AutoCorrector
+
+          MSG = 'Use `have_current_path` on `page` to wait for the URL.'
+          RESTRICT_ON_SEND = %i[expect].freeze
+          PATH_MATCHERS = {
+            to: 'have_current_path',
+            not_to: 'have_no_current_path',
+            to_not: 'have_no_current_path'
+          }.freeze
+
+          # @!method url_actual(node)
+          def_node_matcher :url_actual, <<~PATTERN
+            (send nil? :expect
+              $(send {(send nil? :page) nil?} :current_url))
+          PATTERN
+
+          # @!method supported_matcher?(node)
+          def_node_matcher :supported_matcher?, <<~PATTERN
+            {(send nil? :eq _)
+             (send nil? :match _)
+             (send nil? {:include :start_with :end_with} (str _))}
+          PATTERN
+
+          # @!method expectation_runner?(node)
+          def_node_matcher :expectation_runner?, <<~PATTERN
+            (send (send nil? :expect _) {:to :not_to :to_not} _)
+          PATTERN
+
+          def self.autocorrect_incompatible_with
+            [Style::TrailingCommaInArguments]
+          end
+
+          def on_send(node)
+            actual = url_actual(node)
+            return unless actual
+
+            runner = node.parent
+            return unless expectation_runner?(runner)
+
+            matcher = runner.first_argument
+            return unless supported_matcher?(matcher)
+
+            register_offense(node.loc.selector, actual, runner, matcher)
+          end
+          alias on_csend on_send
+
+          private
+
+          def register_offense(range, actual, runner, matcher)
+            regexp = if matcher.method?(:match)
+                       regexp_source(matcher.first_argument)
+                     end
+            unless correctable_matcher?(matcher, regexp)
+              return add_offense(range)
+            end
+
+            add_offense(range) do |corrector|
+              autocorrect(corrector, actual, runner, matcher, regexp)
+            end
+          end
+
+          def correctable_matcher?(matcher, regexp)
+            return true if matcher.method?(:eq)
+            return false unless matcher.method?(:match)
+
+            matcher.first_argument.regexp_type? || regexp
+          end
+
+          def regexp_source(argument)
+            return unless argument.str_type?
+            return if argument.value.match?(/#[{@$]/)
+
+            Regexp.new(argument.value).inspect
+          rescue RegexpError
+            nil
+          end
+
+          def autocorrect(corrector, actual, runner, matcher, regexp)
+            corrector.replace(actual, 'page')
+            unless runner.method?(:to)
+              corrector.replace(runner.loc.selector, 'to')
+            end
+            corrector.replace(matcher.loc.selector,
+                              PATH_MATCHERS.fetch(runner.method_name))
+            return unless matcher.method?(:match)
+
+            corrector.replace(matcher.first_argument, regexp) if regexp
+            corrector.insert_after(matcher.first_argument, ', url: true')
+          end
+        end
+      end
+    end
+  end
+end