rubocop-capybara 2.22.1 → 2.23.0

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

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

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

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

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

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

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

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