rubocop-rspec 1.38.1 → 1.43.0

data/lib/rubocop-rspec.rb

@@ -11,18 +11,21 @@ require_relative 'rubocop/rspec/inject'
 require_relative 'rubocop/rspec/node'
 require_relative 'rubocop/rspec/top_level_describe'
 require_relative 'rubocop/rspec/wording'
-require_relative 'rubocop/rspec/util'
 require_relative 'rubocop/rspec/language'
 require_relative 'rubocop/rspec/language/node_pattern'
+require_relative 'rubocop/rspec/top_level_group'
 require_relative 'rubocop/rspec/concept'
 require_relative 'rubocop/rspec/example_group'
 require_relative 'rubocop/rspec/example'
 require_relative 'rubocop/rspec/hook'
+require_relative 'rubocop/rspec/variable'
+require_relative 'rubocop/cop/rspec/base'
 require_relative 'rubocop/cop/rspec/cop'
 require_relative 'rubocop/rspec/align_let_brace'
 require_relative 'rubocop/rspec/factory_bot'
 require_relative 'rubocop/rspec/final_end_location'
-require_relative 'rubocop/rspec/blank_line_separation'
+require_relative 'rubocop/rspec/empty_line_separation'
+require_relative 'rubocop/rspec/corrector/move_node'
 
 RuboCop::RSpec::Inject.defaults!
 

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

@@ -17,36 +17,29 @@ module RuboCop
       #     let(:baz)    { bar }
       #     let(:a)      { b }
       #
-      class AlignLeftLetBrace < Cop
+      class AlignLeftLetBrace < Base
+        extend AutoCorrector
+
         MSG = 'Align left let brace'
 
         def self.autocorrect_incompatible_with
           [Layout::ExtraSpacing]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
-          token_aligner.offending_tokens.each do |let|
-            add_offense(let, location: :begin)
-          end
-        end
+          token_aligner =
+            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
 
-        def autocorrect(let)
-          lambda do |corrector|
-            corrector.insert_before(
-              let.loc.begin,
-              token_aligner.indent_for(let)
-            )
+          token_aligner.offending_tokens.each do |let|
+            add_offense(let.loc.begin) do |corrector|
+              corrector.insert_before(
+                let.loc.begin, token_aligner.indent_for(let)
+              )
+            end
           end
         end
-
-        private
-
-        def token_aligner
-          @token_aligner ||=
-            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :begin)
-        end
       end
     end
   end

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

@@ -17,36 +17,29 @@ module RuboCop
       #     let(:baz)    { bar      }
       #     let(:a)      { b        }
       #
-      class AlignRightLetBrace < Cop
+      class AlignRightLetBrace < Base
+        extend AutoCorrector
+
         MSG = 'Align right let brace'
 
         def self.autocorrect_incompatible_with
           [Layout::ExtraSpacing]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
-          token_aligner.offending_tokens.each do |let|
-            add_offense(let, location: :end)
-          end
-        end
+          token_aligner =
+            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
 
-        def autocorrect(let)
-          lambda do |corrector|
-            corrector.insert_before(
-              let.loc.end,
-              token_aligner.indent_for(let)
-            )
+          token_aligner.offending_tokens.each do |let|
+            add_offense(let.loc.end) do |corrector|
+              corrector.insert_before(
+                let.loc.end, token_aligner.indent_for(let)
+              )
+            end
           end
         end
-
-        private
-
-        def token_aligner
-          @token_aligner ||=
-            RuboCop::RSpec::AlignLetBrace.new(processed_source.ast, :end)
-        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module RuboCop
       #       allow(my_instance).to receive(:foo)
       #     end
       #   end
-      class AnyInstance < Cop
+      class AnyInstance < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
 
         def_node_matcher :disallowed_stub, <<-PATTERN

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

@@ -25,7 +25,7 @@ module RuboCop
       #     some_method
       #     test.run
       #   end
-      class AroundBlock < Cop
+      class AroundBlock < Base
         MSG_NO_ARG     = 'Test object should be passed to around block.'
         MSG_UNUSED_ARG = 'You should call `%<arg>s.call` '\
                          'or `%<arg>s.run`.'

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # @abstract parent class to RSpec cops
+      #
+      # The criteria for whether rubocop-rspec analyzes a certain ruby file
+      # is configured via `AllCops/RSpec`. For example, if you want to
+      # customize your project to scan all files within a `test/` directory
+      # then you could add this to your configuration:
+      #
+      # @example configuring analyzed paths
+      #   # .rubocop.yml
+      #   # AllCops:
+      #   #   RSpec:
+      #   #     Patterns:
+      #   #     - '_test.rb$'
+      #   #     - '(?:^|/)test/'
+      class Base < ::RuboCop::Cop::Base
+        include RuboCop::RSpec::Language
+        include RuboCop::RSpec::Language::NodePattern
+
+        DEFAULT_CONFIGURATION =
+          RuboCop::RSpec::CONFIG.fetch('AllCops').fetch('RSpec')
+
+        DEFAULT_PATTERN_RE = Regexp.union(
+          DEFAULT_CONFIGURATION.fetch('Patterns')
+                               .map(&Regexp.public_method(:new))
+        )
+
+        # Invoke the original inherited hook so our cops are recognized
+        def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
+          RuboCop::Cop::Base.inherited(subclass)
+        end
+
+        def relevant_file?(file)
+          relevant_rubocop_rspec_file?(file) && super
+        end
+
+        private
+
+        def relevant_rubocop_rspec_file?(file)
+          rspec_pattern.match?(file)
+        end
+
+        def rspec_pattern
+          if rspec_pattern_config?
+            Regexp.union(rspec_pattern_config.map(&Regexp.public_method(:new)))
+          else
+            DEFAULT_PATTERN_RE
+          end
+        end
+
+        def all_cops_config
+          config
+            .for_all_cops
+        end
+
+        def rspec_pattern_config?
+          return unless all_cops_config.key?('RSpec')
+
+          all_cops_config.fetch('RSpec').key?('Patterns')
+        end
+
+        def rspec_pattern_config
+          all_cops_config
+            .fetch('RSpec', DEFAULT_CONFIGURATION)
+            .fetch('Patterns')
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module RuboCop
       #   expect(foo).to be 1.0
       #   expect(foo).to be(true)
       #
-      class Be < Cop
+      class Be < Base
         MSG = 'Don\'t use `be` without an argument.'
 
         def_node_matcher :be_without_args, <<-PATTERN
@@ -28,7 +28,7 @@ module RuboCop
 
         def on_send(node)
           be_without_args(node) do |matcher|
-            add_offense(matcher, location: :selector)
+            add_offense(matcher.loc.selector)
           end
         end
       end

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

@@ -35,7 +35,9 @@ module RuboCop
       # necessarily the same type as `b` since the `#==` operator can
       # coerce objects for comparison.
       #
-      class BeEql < Cop
+      class BeEql < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `be` over `eql`.'
 
         def_node_matcher :eql_type_with_identity, <<-PATTERN
@@ -44,13 +46,11 @@ module RuboCop
 
         def on_send(node)
           eql_type_with_identity(node) do |eql|
-            add_offense(eql, location: :selector)
+            add_offense(eql.loc.selector) do |corrector|
+              corrector.replace(eql.loc.selector, 'be')
+            end
           end
         end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'be') }
-        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
       #     before(:each) { Widget.create }
       #     after(:each) { Widget.delete_all }
       #   end
-      class BeforeAfterAll < Cop
+      class BeforeAfterAll < Base
         MSG = 'Beware of using `%<hook>s` as it may cause state to leak '\
               'between tests. If you are using `rspec-rails`, and '\
               '`use_transactional_fixtures` is enabled, then records created '\

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

@@ -23,7 +23,9 @@ module RuboCop
         #   expect(page).to have_current_path("/callback")
         #   expect(page).to have_current_path(/widgets/)
         #
-        class CurrentPathExpectation < Cop
+        class CurrentPathExpectation < Base
+          extend AutoCorrector
+
           MSG = 'Do not set an RSpec expectation on `current_path` in ' \
                 'Capybara feature specs - instead, use the ' \
                 '`have_current_path` matcher on `page`'
@@ -47,30 +49,30 @@ module RuboCop
 
           def on_send(node)
             expectation_set_on_current_path(node) do
-              add_offense(node, location: :selector)
+              add_offense(node.loc.selector) do |corrector|
+                next unless node.chained?
+
+                autocorrect(corrector, node)
+              end
             end
           end
 
-          def autocorrect(node)
-            lambda do |corrector|
-              return unless node.chained?
+          private
 
-              as_is_matcher(node.parent) do |to_sym, matcher_node|
-                rewrite_expectation(corrector, node, to_sym, matcher_node)
-              end
+          def autocorrect(corrector, node)
+            as_is_matcher(node.parent) do |to_sym, matcher_node|
+              rewrite_expectation(corrector, node, to_sym, matcher_node)
+            end
 
-              regexp_str_matcher(node.parent) do |to_sym, matcher_node, regexp|
-                rewrite_expectation(corrector, node, to_sym, matcher_node)
-                convert_regexp_str_to_literal(corrector, matcher_node, regexp)
-              end
+            regexp_str_matcher(node.parent) do |to_sym, matcher_node, regexp|
+              rewrite_expectation(corrector, node, to_sym, matcher_node)
+              convert_regexp_str_to_literal(corrector, matcher_node, regexp)
             end
           end
 
-          private
-
           def rewrite_expectation(corrector, node, to_symbol, matcher_node)
             current_path_node = node.first_argument
-            corrector.replace(current_path_node.loc.expression, 'page')
+            corrector.replace(current_path_node, 'page')
             corrector.replace(node.parent.loc.selector, 'to')
             matcher_method = if to_symbol == :to
                                'have_current_path'
@@ -84,7 +86,7 @@ module RuboCop
           def convert_regexp_str_to_literal(corrector, matcher_node, regexp_str)
             str_node = matcher_node.first_argument
             regexp_expr = Regexp.new(regexp_str).inspect
-            corrector.replace(str_node.loc.expression, regexp_expr)
+            corrector.replace(str_node, regexp_expr)
           end
 
           # `have_current_path` with no options will include the querystring
@@ -97,7 +99,7 @@ module RuboCop
             return if %i[regexp str].include?(expectation_last_child.type)
 
             corrector.insert_after(
-              expectation_last_child.loc.expression,
+              expectation_last_child,
               ', ignore_query: true'
             )
           end

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

@@ -40,7 +40,9 @@ module RuboCop
         #       # ...
         #     end
         #   end
-        class FeatureMethods < Cop
+        class FeatureMethods < Base
+          extend AutoCorrector
+
           MSG = 'Use `%<replacement>s` instead of `%<method>s`.'
 
           # https://git.io/v7Kwr
@@ -53,15 +55,18 @@ module RuboCop
             feature:    :describe
           }.freeze
 
+          def_node_matcher :capybara_speak,
+                           SelectorSet.new(MAP.keys).node_pattern_union
+
           def_node_matcher :spec?, <<-PATTERN
             (block
-              (send #{RSPEC} {:describe :feature} ...)
+              (send #rspec? {:describe :feature} ...)
             ...)
           PATTERN
 
           def_node_matcher :feature_method, <<-PATTERN
             (block
-              $(send #{RSPEC} ${#{MAP.keys.map(&:inspect).join(' ')}} ...)
+              $(send #rspec? $#capybara_speak ...)
             ...)
           PATTERN
 
@@ -71,18 +76,15 @@ module RuboCop
             feature_method(node) do |send_node, match|
               next if enabled?(match)
 
-              add_offense(
-                send_node,
-                location: :selector,
-                message: format(MSG, method: match, replacement: MAP[match])
-              )
+              add_offense(send_node.loc.selector) do |corrector|
+                corrector.replace(send_node.loc.selector, MAP[match].to_s)
+              end
             end
           end
 
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.selector, MAP[node.method_name].to_s)
-            end
+          def message(range)
+            name = range.source.to_sym
+            format(MSG, method: name, replacement: MAP[name])
           end
 
           private

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      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`.
+        # (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 < Base
+          MSG_FALSE = 'Use `:all` or `:hidden` instead of `false`.'
+          MSG_TRUE = 'Use `:visible` instead of `true`.'
+          CAPYBARA_MATCHER_METHODS = %i[
+            have_selector
+            have_css
+            have_xpath
+            have_link
+            have_button
+            have_field
+            have_select
+            have_table
+            have_checked_field
+            have_unchecked_field
+            have_text
+            have_content
+          ].freeze
+
+          def_node_matcher :visible_true?, <<~PATTERN
+            (send nil? #capybara_matcher? ... (hash <$(pair (sym :visible) true) ...>))
+          PATTERN
+
+          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