rubocop-capybara 3.0.0 → 3.1.0

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

@@ -9,7 +9,7 @@ module RuboCop
           extend NodePattern::Macros
 
           EXPLICIT_MATCHER = %w[css selector style xpath].map do |suffix|
-            "matches_#{suffix}?".to_sym
+            :"matches_#{suffix}?"
           end.freeze
           MSG_INFLECTED = 'Prefer using `%<matcher_name>s` matcher over ' \
                           '`%<predicate_name>s`.'
@@ -19,6 +19,8 @@ module RuboCop
           def check_inflected(node)
             predicate_in_actual?(node) do |predicate, to, matcher|
               msg = message_inflected(predicate)
+              next add_offense(node, message: msg) if predicate.block_node
+
               add_offense(node, message: msg) do |corrector|
                 remove_predicate(corrector, predicate)
                 corrector.replace(node.loc.selector,
@@ -93,7 +95,7 @@ module RuboCop
 
           def true?(to_symbol, matcher)
             result = case matcher.method_name
-                     when :be, :eq
+                     when :be, :eq, :eql, :equal
                        matcher.first_argument.true_type?
                      when :be_truthy, :a_truthy_value
                        true
@@ -118,6 +120,12 @@ module RuboCop
           INFLECTED_MATCHER = %w[css selector style xpath].each.map do |suffix|
             "match_#{suffix}"
           end.freeze
+          SAFE_RECEIVER_TYPES = Set.new(
+            %i[
+              array complex const cvar dstr false float gvar hash int ivar
+              lvar nil rational regexp self str sym true xstr
+            ]
+          ).freeze
 
           private
 
@@ -127,8 +135,10 @@ module RuboCop
 
           def check_explicit(node) # rubocop:disable Metrics/MethodLength
             predicate_matcher?(node) do |actual, matcher|
-              add_offense(node,
-                          message: message_explicit(matcher)) do |corrector|
+              msg = message_explicit(matcher)
+              next add_offense(node, message: msg) if matcher.block_node
+
+              add_offense(node, message: msg) do |corrector|
                 corrector_explicit(corrector, node, actual, matcher)
               end
             end
@@ -169,14 +179,40 @@ module RuboCop
           def move_predicate(corrector, actual, matcher)
             predicate = to_predicate_method(matcher.method_name)
             args = args_loc(matcher).source
-            corrector.insert_after(actual,
-                                   ".#{predicate}" + args)
+            replacement = ".#{predicate}#{args}"
+
+            if actual_requires_parentheses?(actual)
+              corrector.replace(actual, "(#{actual.source})#{replacement}")
+            else
+              corrector.insert_after(actual, replacement)
+            end
           end
 
           def to_predicate_method(matcher)
             "#{matcher.to_s.sub('match_', 'matches_')}?"
           end
 
+          def actual_requires_parentheses?(actual)
+            return false if actual.begin_type?
+
+            if actual.call_type?
+              return actual_send_requires_parentheses?(actual)
+            end
+
+            !safe_receiver?(actual)
+          end
+
+          def actual_send_requires_parentheses?(actual)
+            return false if actual.method?(:[])
+
+            actual.operator_method? ||
+              (actual.arguments? && !actual.parenthesized?)
+          end
+
+          def safe_receiver?(actual)
+            SAFE_RECEIVER_TYPES.include?(actual.type)
+          end
+
           # rubocop:disable Metrics/MethodLength
           def replacement_matcher(node)
             case [cop_config['Strict'], node.method?(:to)]
@@ -241,7 +277,7 @@ module RuboCop
         #   # good - the above code is rewritten to it by this cop
         #   expect(foo.matches_style?(bar: 'baz')).to be_truthy
         #
-        class PredicateMatcher < ::RuboCop::Cop::Base
+        class PredicateMatcher < RuboCop::Cop::Base
           extend AutoCorrector
           include ConfigurableEnforcedStyle
           include InflectedHelper

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

@@ -26,7 +26,7 @@ module RuboCop
         #   expect(page).to have_select
         #   expect(page).to have_field(with: 'foo')
         #
-        class SpecificMatcher < ::RuboCop::Cop::Base
+        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
@@ -37,6 +37,7 @@ module RuboCop
             'select' => 'select',
             'input' => 'field'
           }.freeze
+          EXCLUDED_FIELD_TYPES = %w[hidden image submit].freeze
 
           # @!method first_argument(node)
           def_node_matcher :first_argument, <<~PATTERN
@@ -61,11 +62,16 @@ module RuboCop
           private
 
           def specific_matcher(arg)
-            splitted_arg = arg[/^\w+/, 0]
+            splitted_arg = arg[/^[\w-]+/, 0]
             SPECIFIC_MATCHER[splitted_arg]
           end
 
           def replaceable?(node, arg, matcher)
+            if matcher == 'field'
+              type = CssSelector.attributes(arg)['type'].to_s.downcase
+              return false if EXCLUDED_FIELD_TYPES.include?(type)
+            end
+
             replaceable_attributes?(arg) &&
               !text_with_regexp?(node) &&
               CapybaraHelp.replaceable_option?(node, arg, matcher) &&

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Capybara
       module RSpec
-        # Checks for boolean visibility in Capybara finders.
+        # Checks for boolean visibility in Capybara RSpec matchers.
         #
         # Capybara lets you find elements that match a certain visibility using
         # the `:visible` option. `:visible` accepts both boolean and symbols as
@@ -12,12 +12,19 @@ module RuboCop
         # 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`.
+        # Only `true` is autocorrected, to `:visible`.
+        # Set `DefaultSelector` to match `Capybara.default_selector`, or to
+        # `null` if it varies at runtime.
         # Read more at: https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all
         #
+        # @safety
+        #   This cop's autocorrection is unsafe because custom filters on
+        #   built-in selectors may treat `true` and `:visible` differently.
+        #
         # @example
         #   # bad
-        #   expect(page).to have_selector('.foo', visible: false)
-        #   expect(page).to have_css('.foo', visible: true)
+        #   expect(page).to have_selector('.foo', visible: true)
+        #   expect(page).to have_css('.foo', visible: false)
         #   expect(page).to have_link('my link', visible: false)
         #
         #   # good
@@ -25,25 +32,11 @@ module RuboCop
         #   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
+        class VisibilityMatcher < RuboCop::Cop::Base
+          extend AutoCorrector
+          include Visibility
 
-          RESTRICT_ON_SEND = CAPYBARA_MATCHER_METHODS
+          RESTRICT_ON_SEND = CapybaraHelp::VISIBILITY_MATCHER_METHODS
 
           # @!method visible_true?(node)
           def_node_matcher :visible_true?, <<~PATTERN
@@ -56,14 +49,26 @@ module RuboCop
           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) }
+            visible_false?(node) { |arg| check_visibility(arg) }
+            visible_true?(node) do |arg|
+              check_visibility(arg) { autocorrectable?(node, arg) }
+            end
           end
 
           private
 
           def capybara_matcher?(method_name)
-            CAPYBARA_MATCHER_METHODS.include? method_name
+            RESTRICT_ON_SEND.include? method_name
+          end
+
+          def autocorrectable?(node, pair)
+            if QueryMethods.selector(node.method_name) == :selector
+              selector = node.first_argument
+              # An unknown argument may be a custom selector name.
+              return false unless selector.type?(:hash, :sym, :str, :dstr)
+            end
+
+            supported_visibility_query?(node, pair.parent)
           end
         end
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Cops for the `Capybara/RSpec` department. The department's cops are
+      # registered for lazy loading and their files are loaded on demand.
+      module RSpec
+        extend LazyLoader
+
+        register_cop :CurrentPathExpectation, "#{__dir__}/rspec/current_path_expectation"
+        register_cop :CurrentUrlExpectation, "#{__dir__}/rspec/current_url_expectation"
+        register_cop :FindElementValueEq, "#{__dir__}/rspec/find_element_value_eq"
+        register_cop :HaveContent, "#{__dir__}/rspec/have_content"
+        register_cop :HaveSelector, "#{__dir__}/rspec/have_selector"
+        register_cop :MatchStyle, "#{__dir__}/rspec/match_style"
+        register_cop :NegationMatcher, "#{__dir__}/rspec/negation_matcher"
+        register_cop :NegationMatcherAfterVisit, "#{__dir__}/rspec/negation_matcher_after_visit"
+        register_cop :PredicateMatcher, "#{__dir__}/rspec/predicate_matcher"
+        register_cop :SpecificMatcher, "#{__dir__}/rspec/specific_matcher"
+        register_cop :VisibilityMatcher, "#{__dir__}/rspec/visibility_matcher"
+      end
+    end
+  end
+end

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

@@ -8,18 +8,18 @@ module RuboCop
       # @example
       #
       #   # bad
-      #   find('a').click
+      #   find('a[href="/home"]').click
       #   find('button.cls').click
-      #   find('a', exact_text: 'foo').click
+      #   find('a[href="/home"]', exact_text: 'foo').click
       #   find('div button').click
       #
       #   # good
-      #   click_link
+      #   click_link(href: '/home')
       #   click_button(class: 'cls')
-      #   click_link(exact_text: 'foo')
+      #   click_link(href: '/home', exact_text: 'foo')
       #   find('div').click_button
       #
-      class SpecificActions < ::RuboCop::Cop::Base
+      class SpecificActions < RuboCop::Cop::Base
         MSG = "Prefer `%<good_action>s` over `find('%<selector>s').click`."
         RESTRICT_ON_SEND = %i[click].freeze
         SPECIFIC_ACTION = {
@@ -33,6 +33,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if node.arguments? || node.block_node
+
           click_on_selector(node.receiver) do |arg|
             next unless supported_selector?(arg)
             # Always check the last selector in the case of multiple selectors
@@ -51,7 +53,7 @@ module RuboCop
         private
 
         def specific_action(selector)
-          SPECIFIC_ACTION[last_selector(selector)]
+          SPECIFIC_ACTION[selector]
         end
 
         def replaceable?(node, arg, action)
@@ -71,7 +73,10 @@ module RuboCop
         end
 
         def last_selector(arg)
-          arg.split.last[/^\w+/, 0]
+          without_attributes = arg.gsub(/\[(?:'[^']*'|"[^"]*"|[^\]])*\]/) do |m|
+            m.gsub(/\s/, '')
+          end
+          without_attributes.split.last&.[](/^[\w-]+/, 0)
         end
 
         def offense_range(node, receiver)

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

@@ -3,6 +3,43 @@
 module RuboCop
   module Cop
     module Capybara
+      # Help methods for SpecificFinders.
+      # @api private
+      module SpecificFindersHelp
+        MESSAGE = 'Prefer `%<good_finder>s` over `find`.'
+        FIELD_OPTIONS = CapybaraHelp::SPECIFIC_OPTIONS['field']
+        FIELD_SELECTOR_PATTERN = /\Ainput(?:\[.+\])+\z/.freeze
+        UNSAFE_FIELD_TYPES = %w[hidden image submit].freeze
+        FIELD_STATE_OPTIONS = %w[checked disabled multiple readonly].freeze
+
+        module_function
+
+        def field_selector?(arg)
+          return false unless FIELD_SELECTOR_PATTERN.match?(arg)
+
+          attrs = CssSelector.attributes(arg)
+          type = attrs['type'].to_s.downcase
+          return false if UNSAFE_FIELD_TYPES.include?(type)
+          return false if (attrs.keys & FIELD_STATE_OPTIONS).any?
+
+          CapybaraHelp.replaceable_attributes?(attrs) &&
+            attrs.keys.all? { |attr| FIELD_OPTIONS.include?(attr) }
+        end
+
+        def options(attrs)
+          attrs.filter_map { |key, value| "#{key}: #{yield(value)}" }.join(', ')
+        end
+
+        def unsupported_selector?(arg)
+          CssSelector.pseudo_classes(arg).any? ||
+            CssSelector.multiple_selectors?(arg)
+        end
+
+        def message(finder)
+          format(MESSAGE, good_finder: finder)
+        end
+      end
+
       # Checks if there is a more specific finder offered by Capybara.
       #
       # @example
@@ -11,43 +48,90 @@ module RuboCop
       #   find('[id=some-id]')
       #   find(:css, '#some-id')
       #   find(:id, 'some-id')
+      #   find(:link, 'Home')
+      #   find(:field, 'Name')
+      #   find('input[placeholder="Email"]')
+      #   find(:css, 'input[type="checkbox"]')
       #
       #   # good
       #   find_by_id('some-id')
+      #   find_link('Home')
+      #   find_field('Name')
+      #   find_field(placeholder: 'Email')
+      #   find_field(type: 'checkbox')
       #
-      class SpecificFinders < ::RuboCop::Cop::Base
+      class SpecificFinders < RuboCop::Cop::Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include RangeHelp
 
-        MSG = 'Prefer `find_by_id` over `find`.'
+        MSG = 'Prefer `%<replacement>s` over `find`.'
         RESTRICT_ON_SEND = %i[find].freeze
 
         # @!method find_argument(node)
         def_node_matcher :find_argument, <<~PATTERN
-          (send _ :find $(sym {:css :id})? (str $_) ...)
+          (send _ :find $(sym {:css :id :link :field})? (str $_) ...)
         PATTERN
 
-        # @!method class_options(node)
-        def_node_search :class_options, <<~PATTERN
-          (pair (sym :class) $_ ...)
+        # @!method class_option(node)
+        def_node_matcher :class_option, <<~PATTERN
+          (send _ :find ... (hash <(pair (sym :class) $_) ...>))
         PATTERN
 
         def on_send(node)
           find_argument(node) do |sym, arg|
-            next if CssSelector.pseudo_classes(arg).any?
-            next if CssSelector.multiple_selectors?(arg)
-
-            on_attr(node, sym, arg) if attribute?(arg)
-            on_id(node, sym, arg) if CssSelector.id?(arg)
-            on_sym_id(node, sym, arg) if sym.first&.value == :id
+            handle_find(node, sym, arg)
           end
         end
 
         private
 
+        def selector?(sym)
+          %i[link field].include?(sym.first.value)
+        end
+
+        def id_symbol?(sym)
+          sym.first&.value == :id
+        end
+
+        def selector_symbol?(sym)
+          sym.first && selector?(sym)
+        end
+
+        def on_sym_selector(node, sym)
+          replacement = "find_#{sym.first.value}"
+          register_selector_offense(node, replacement)
+        end
+
+        def register_selector_offense(node, replacement)
+          message = format(MSG, replacement: replacement)
+          add_offense(offense_range(node), message: message) do |corrector|
+            corrector.replace(node.loc.selector, replacement)
+            remove_selector_argument(corrector, node)
+          end
+        end
+
+        def remove_selector_argument(corrector, node)
+          range = range_between(node.first_argument.source_range.begin_pos,
+                                node.arguments[1].source_range.begin_pos)
+          corrector.remove(range)
+        end
+
+        def handle_find(node, sym, arg)
+          return on_sym_id(node, sym, arg) if id_symbol?(sym)
+          return on_sym_selector(node, sym) if selector_symbol?(sym)
+          return if SpecificFindersHelp.unsupported_selector?(arg)
+
+          if SpecificFindersHelp.field_selector?(arg)
+            return on_field(node, sym, arg)
+          end
+          return on_attr(node, sym, arg) if attribute?(arg)
+
+          on_id(node, sym, arg) if CssSelector.id?(arg)
+        end
+
         def on_attr(node, sym, arg)
           attrs = CssSelector.attributes(arg)
-          return unless (id = attrs['id'])
+          return unless (id = attrs['id']&.to_s)
           return if attrs['class']
 
           register_offense(node, sym, replaced_arguments(arg, id))
@@ -57,12 +141,29 @@ module RuboCop
           return if CssSelector.attributes(arg).any?
 
           id = CssSelector.id(arg)
-          register_offense(node, sym, "'#{id}'",
+          register_offense(node, sym, ruby_literal(id.delete('\\')),
                            CssSelector.classes(arg.sub("##{id}", '')))
         end
 
         def on_sym_id(node, sym, id)
-          register_offense(node, sym, "'#{id}'")
+          register_offense(node, sym, ruby_literal(id))
+        end
+
+        def on_field(node, sym, arg)
+          add_offense(
+            offense_range(node),
+            message: SpecificFindersHelp.message('find_field')
+          ) do |corrector|
+            corrector.replace(node.loc.selector, 'find_field')
+            corrector.replace(node.first_argument, field_options(arg))
+            corrector.remove(deletion_range(node)) unless sym.empty?
+          end
+        end
+
+        def field_options(arg)
+          SpecificFindersHelp.options(CssSelector.attributes(arg)) do |value|
+            ruby_literal(value)
+          end
         end
 
         def attribute?(arg)
@@ -70,24 +171,36 @@ module RuboCop
             CapybaraHelp.common_attributes?(arg)
         end
 
-        def register_offense(node, sym, id, classes = [])
-          add_offense(offense_range(node)) do |corrector|
+        def register_offense(node, sym, replacement, classes = [])
+          message = format(MSG, replacement: 'find_by_id')
+          add_offense(offense_range(node), message: message) do |corrector|
+            next unless autocorrectable_classes?(node, classes)
+
             corrector.replace(node.loc.selector, 'find_by_id')
-            corrector.replace(node.first_argument, id.delete('\\'))
-            unless classes.compact.empty?
-              autocorrect_classes(corrector, node, classes)
-            end
+            corrector.replace(node.first_argument, replacement)
+            autocorrect_id_classes(corrector, node, classes)
             corrector.remove(deletion_range(node)) unless sym.empty?
           end
         end
 
+        def autocorrectable_classes?(node, classes)
+          return true if classes.empty? || !(options = class_option(node))
+
+          options.str_type? ||
+            (options.array_type? && options.values.all?(&:str_type?))
+        end
+
+        def autocorrect_id_classes(corrector, node, classes)
+          autocorrect_classes(corrector, node, classes) unless classes.empty?
+        end
+
         def deletion_range(node)
           range_between(node.first_argument.source_range.end_pos,
                         node.arguments[1].source_range.end_pos)
         end
 
         def autocorrect_classes(corrector, node, classes)
-          if (options = class_options(node).first)
+          if (options = class_option(node))
             append_options(classes, options)
             corrector.replace(options, classes.to_s)
           else
@@ -108,6 +221,8 @@ module RuboCop
 
         def replaced_arguments(arg, id)
           options = to_options(CssSelector.attributes(arg))
+          id = ruby_literal(id.delete('\\'))
+
           options.empty? ? id : "#{id}, #{options}"
         end
 
@@ -115,20 +230,26 @@ module RuboCop
           attrs.each.filter_map do |key, value|
             next if key == 'id'
 
-            "#{key}: #{value}"
+            "#{key}: #{ruby_literal(value)}"
           end.join(', ')
         end
 
+        def ruby_literal(value)
+          case value
+          when String
+            "'#{value.gsub(/['\\]/) { |char| "\\#{char}" }}'"
+          when nil then 'nil'
+          else
+            value.to_s
+          end
+        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.source_range.end_pos
-          end
+          node.loc.end ? node.loc.end.end_pos : node.source_range.end_pos
         end
       end
     end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks positional access to Capybara windows, whose order is undefined.
+      #
+      # @example
+      #   # bad
+      #   popup = windows.last
+      #   original = page.windows.first
+      #
+      #   # good
+      #   popup = window_opened_by { click_link 'Open' }
+      #   original = current_window
+      #
+      class UnorderedWindowAccess < RuboCop::Cop::Base
+        MSG = 'Selecting a window by position relies on undefined order. ' \
+              'Use `window_opened_by` or `current_window`.'
+        RESTRICT_ON_SEND = %i[first last [] at fetch].freeze
+
+        # @!method capybara_windows?(node)
+        def_node_matcher :capybara_windows?, <<~PATTERN
+          (call
+            {nil? self
+             (call {nil? self} :page)
+             (call (const {nil? cbase} :Capybara) :current_session)}
+            :windows)
+        PATTERN
+
+        def on_send(node)
+          return if node.method?(:[]) && node.first_argument&.type?(:range)
+
+          add_offense(node) if capybara_windows?(node.receiver)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Capybara
+      # Checks for boolean values passed to Capybara's `visible` option.
+      #
+      # `visible: false` finds both visible and hidden elements, rather than
+      # only hidden elements. Use `:all`, `:hidden` or `:visible` instead.
+      # Only `true` is autocorrected, to `:visible`.
+      #
+      # This cop targets Capybara's built-in selectors. Set `DefaultSelector`
+      # to match `Capybara.default_selector`, or to `null` if it varies at
+      # runtime. Queries using custom or unknown selectors are skipped.
+      #
+      # @example
+      #   # bad
+      #   find('.menu', visible: true)
+      #   expect(page).to have_css('.menu', visible: false)
+      #
+      #   # good
+      #   find('.menu', visible: :visible)
+      #   find('.menu', visible: :all)
+      #   find('.menu', visible: :hidden)
+      #
+      # @example DefaultSelector: custom
+      #   # bad
+      #   find(:css, '.menu', visible: true)
+      #
+      #   # good
+      #   find('.menu', visible: true)
+      #
+      class VisibilityOption < RuboCop::Cop::Base
+        extend AutoCorrector
+        include CapybaraHelp
+        include Visibility
+
+        RESTRICT_ON_SEND = QueryMethods.names(
+          :finder, :collection, :selector, :match, :action, :grouped
+        ).difference(CapybaraHelp::VISIBILITY_MATCHER_METHODS).freeze
+
+        # @!method visibility_options(node)
+        def_node_matcher :visibility_options, <<~PATTERN
+          (call #capybara_receiver? _ <$(hash ...) ...>)
+        PATTERN
+
+        # @!method boolean_visibility?(node)
+        def_node_matcher :boolean_visibility?, <<~PATTERN
+          (pair (sym :visible) boolean)
+        PATTERN
+
+        def on_send(node)
+          return unless (options = visibility_options(node))
+          return unless supported_visibility_query?(node, options)
+
+          options.pairs.each do |pair|
+            check_visibility(pair) if boolean_visibility?(pair)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end