rubocop-rspec 1.44.0 → 2.1.0

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

@@ -23,7 +23,7 @@ module RuboCop
       class ExpectInHook < Base
         MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'
 
-        def_node_search :expectation, Expectations::ALL.send_pattern
+        def_node_search :expectation, send_pattern('#Expectations.all')
 
         def on_block(node)
           return unless hook?(node)

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

@@ -15,7 +15,7 @@ module RuboCop
       #   # good
       #   expect { my_app.print_report }.to output('Hello World').to_stdout
       class ExpectOutput < Base
-        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` '\
+        MSG = 'Use `expect { ... }.to output(...).to_%<name>s` ' \
               'instead of mutating $%<name>s.'
 
         def on_gvasgn(node)

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

@@ -57,7 +57,7 @@ module RuboCop
       #   my_class_spec.rb         # describe MyClass, '#method'
       #
       class FilePath < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Spec path should end with `%<suffix>s`.'
 
@@ -82,30 +82,39 @@ module RuboCop
         private
 
         def ensure_correct_file_path(send_node, described_class, arguments)
-          glob = glob_for(described_class, arguments.first)
-          return if filename_ends_with?(glob)
-
-          add_offense(send_node, message: format(MSG, suffix: glob))
+          pattern = pattern_for(described_class, arguments.first)
+          return if filename_ends_with?(pattern)
+
+          # For the suffix shown in the offense message, modify the regular
+          # expression pattern to resemble a glob pattern for clearer error
+          # messages.
+          offense_suffix = pattern.gsub('.*', '*').sub('[^/]', '')
+            .sub('\.', '.')
+          add_offense(send_node, message: format(MSG, suffix: offense_suffix))
         end
 
         def routing_spec?(args)
           args.any?(&method(:routing_metadata?))
         end
 
-        def glob_for(described_class, method_name)
-          return glob_for_spec_suffix_only? if spec_suffix_only?
+        def pattern_for(described_class, method_name)
+          return pattern_for_spec_suffix_only? if spec_suffix_only?
 
-          "#{expected_path(described_class)}#{name_glob(method_name)}*_spec.rb"
+          [
+            expected_path(described_class),
+            name_pattern(method_name),
+            '[^/]*_spec\.rb'
+          ].join
         end
 
-        def glob_for_spec_suffix_only?
-          '*_spec.rb'
+        def pattern_for_spec_suffix_only?
+          '.*_spec\.rb'
         end
 
-        def name_glob(method_name)
+        def name_pattern(method_name)
           return unless method_name&.str_type?
 
-          "*#{method_name.str_content.gsub(/\W/, '')}" unless ignore_methods?
+          ".*#{method_name.str_content.gsub(/\W/, '')}" unless ignore_methods?
         end
 
         def expected_path(constant)
@@ -131,11 +140,9 @@ module RuboCop
           cop_config['IgnoreMethods']
         end
 
-        def filename_ends_with?(glob)
-          filename =
-            RuboCop::PathUtil.relative_path(processed_source.buffer.name)
-              .gsub('../', '')
-          File.fnmatch?("*#{glob}", filename)
+        def filename_ends_with?(pattern)
+          filename = File.expand_path(processed_source.buffer.name)
+          filename.match?("#{pattern}$")
         end
 
         def relevant_rubocop_rspec_file?(_file)

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

@@ -20,25 +20,40 @@ module RuboCop
       #   describe MyClass do
       #   end
       class Focus < Base
-        MSG = 'Focused spec found.'
+        extend AutoCorrector
+        include RangeHelp
 
-        focused = ExampleGroups::FOCUSED + Examples::FOCUSED
+        MSG = 'Focused spec found.'
 
-        def_node_matcher :focusable_selector?,
-                         (ExampleGroups::GROUPS + ExampleGroups::SKIPPED +
-                          Examples::EXAMPLES + Examples::SKIPPED +
-                          Examples::PENDING).node_pattern_union
+        def_node_matcher :focusable_selector?, <<-PATTERN
+          {
+            #ExampleGroups.regular
+            #ExampleGroups.skipped
+            #Examples.regular
+            #Examples.skipped
+            #Examples.pending
+          }
+        PATTERN
 
         def_node_matcher :metadata, <<-PATTERN
           {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
            (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
-        def_node_matcher :focused_block?, focused.send_pattern
+        def_node_matcher :focused_block?,
+                         send_pattern(<<~PATTERN)
+                           {#ExampleGroups.focused #Examples.focused}
+                         PATTERN
 
         def on_send(node)
           focus_metadata(node) do |focus|
-            add_offense(focus)
+            add_offense(focus) do |corrector|
+              if focus.pair_type? || focus.str_type? || focus.sym_type?
+                corrector.remove(with_surrounding(focus))
+              elsif focus.send_type?
+                correct_send(corrector, focus)
+              end
+            end
           end
         end
 
@@ -49,6 +64,26 @@ module RuboCop
 
           metadata(node, &block)
         end
+
+        def with_surrounding(focus)
+          range_with_space = range_with_surrounding_space(
+            range: focus.loc.expression,
+            side: :left
+          )
+
+          range_with_surrounding_comma(range_with_space, :left)
+        end
+
+        def correct_send(corrector, focus)
+          range = focus.loc.selector
+          unfocused = focus.method_name.to_s.sub(/^f/, '')
+          unless Examples.regular(unfocused) || ExampleGroups.regular(unfocused)
+            return
+          end
+
+          corrector.replace(range,
+                            range.source.sub(focus.method_name.to_s, unfocused))
+        end
       end
     end
   end

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

@@ -64,13 +64,11 @@ module RuboCop
         IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
-        def_node_matcher :hook?, Hooks::ALL.node_pattern_union
-
         def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send _ #hook? (sym ${:each :example})) ...)
+          (block $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, '(block $(send _ #hook?) ...)'
+        def_node_matcher :unscoped_hook, '(block $(send _ #Hooks.all) ...)'
 
         def on_block(node)
           hook(node) do |method_send, scope_name|

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

@@ -30,8 +30,8 @@ module RuboCop
 
         def_node_matcher :example_or_group?, <<-PATTERN
           {
-            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
-            #{Includes::EXAMPLES.send_pattern}
+            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
+            #{send_pattern('#Includes.examples')}
           }
         PATTERN
 

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :implicit_expect, <<-PATTERN
           {
             (send nil? ${:should :should_not} ...)
-            (send (send nil? $:is_expected) #{Runners::ALL.node_pattern_union} ...)
+            (send (send nil? $:is_expected) #Runners.all ...)
           }
         PATTERN
 

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

@@ -21,7 +21,7 @@ module RuboCop
       class InstanceSpy < Base
         extend AutoCorrector
 
-        MSG = 'Use `instance_spy` when you check your double '\
+        MSG = 'Use `instance_spy` when you check your double ' \
               'with `have_received`.'
 
         def_node_search :null_double, <<-PATTERN

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

@@ -47,7 +47,7 @@ module RuboCop
       #   end
       #
       class InstanceVariable < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Avoid instance variables – use let, ' \
               'a method call, or a local variable (if possible).'

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

@@ -22,7 +22,7 @@ module RuboCop
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including '\
+        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including ' \
               'examples in a nested context.'
 
         def_node_matcher :example_inclusion_offense, '(send _ % ...)'

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

@@ -17,7 +17,7 @@ module RuboCop
       #   end
       class IteratedExpectation < Base
         MSG = 'Prefer using the `all` matcher instead ' \
-                  'of iterating over an array.'
+              'of iterating over an array.'
 
         def_node_matcher :each?, <<-PATTERN
           (block

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

@@ -37,8 +37,8 @@ module RuboCop
 
         def_node_matcher :example_or_group?, <<-PATTERN
           {
-            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
-            #{Includes::EXAMPLES.send_pattern}
+            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
+            #{send_pattern('#Includes.examples')}
           }
         PATTERN
 

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

@@ -29,10 +29,13 @@ module RuboCop
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
         def_node_matcher :example_or_shared_group_or_including?,
-                         (
-                           ExampleGroups::ALL + SharedGroups::ALL +
-                           Includes::ALL
-                         ).block_pattern
+                         block_pattern(<<~PATTERN)
+                           {
+                             #SharedGroups.all
+                             #ExampleGroups.all
+                             #Includes.all
+                           }
+                         PATTERN
 
         def_node_matcher :let_bang, <<-PATTERN
           {

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

@@ -29,14 +29,14 @@ module RuboCop
 
         MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
 
-        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message '\
-                            'expectations. Setup `%<source>s` as a spy using '\
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
+                            'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
         SUPPORTED_STYLES = %w[have_received receive].freeze
 
         def_node_matcher :message_expectation, %(
-          (send (send nil? :expect $_) #{Runners::ALL.node_pattern_union} ...)
+          (send (send nil? :expect $_) #Runners.all ...)
         )
 
         def_node_search :receive_message, %(

data/lib/rubocop/cop/rspec/mixin/empty_line_separation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps determine the offending location if there is not an empty line
+      # following the node. Allows comments to follow directly after.
+      module EmptyLineSeparation
+        include FinalEndLocation
+        include RangeHelp
+
+        def missing_separating_line_offense(node)
+          return if last_child?(node)
+
+          missing_separating_line(node) do |location|
+            msg = yield(node.method_name)
+            add_offense(location, message: msg) do |corrector|
+              corrector.insert_after(location.end, "\n")
+            end
+          end
+        end
+
+        def missing_separating_line(node)
+          line = final_end_location(node).line
+
+          line += 1 while comment_line?(processed_source[line])
+
+          return if processed_source[line].blank?
+
+          yield offending_loc(line)
+        end
+
+        def offending_loc(last_line)
+          offending_line = processed_source[last_line - 1]
+
+          content_length = offending_line.lstrip.length
+          start          = offending_line.length - content_length
+
+          source_range(processed_source.buffer,
+                       last_line, start, content_length)
+        end
+
+        def last_child?(node)
+          return true unless node.parent&.begin_type?
+
+          node.equal?(node.parent.children.last)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/final_end_location.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps find the true end location of nodes which might contain heredocs.
+      module FinalEndLocation
+        def final_end_location(start_node)
+          heredoc_endings =
+            start_node.each_node(:str, :dstr, :xstr)
+              .select(&:heredoc?)
+              .map { |node| node.loc.heredoc_end }
+
+          [start_node.loc.end, *heredoc_endings].max_by(&:line)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/top_level_group.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods for top level example group cops
+      module TopLevelGroup
+        extend RuboCop::NodePattern::Macros
+
+        def on_new_investigation
+          super
+
+          top_level_groups.each do |node|
+            on_top_level_example_group(node) if example_group?(node)
+            on_top_level_group(node)
+          end
+        end
+
+        def top_level_groups
+          @top_level_groups ||=
+            top_level_nodes(root_node).select { |n| spec_group?(n) }
+        end
+
+        private
+
+        # Dummy methods to be overridden in the consumer
+        def on_top_level_example_group(_node); end
+
+        def on_top_level_group(_node); end
+
+        def top_level_group?(node)
+          top_level_groups.include?(node)
+        end
+
+        def top_level_nodes(node)
+          return [] if node.nil?
+
+          case node.type
+          when :begin
+            node.children
+          when :module, :class
+            top_level_nodes(node.body)
+          else
+            [node]
+          end
+        end
+
+        def root_node
+          processed_source.ast
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/variable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps check offenses with variable definitions
+      module Variable
+        extend RuboCop::NodePattern::Macros
+
+        Subjects = RuboCop::RSpec::Language::Subjects
+        Helpers = RuboCop::RSpec::Language::Helpers
+
+        def_node_matcher :variable_definition?, <<~PATTERN
+          (send nil? {#Subjects.all #Helpers.all}
+            $({sym str dsym dstr} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -23,10 +23,9 @@ module RuboCop
       #     end
       #   end
       class MultipleDescribes < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
-        MSG = 'Do not use multiple top-level example groups - '\
-              'try to nest them.'
+        MSG = 'Do not use multiple top-level example groups - try to nest them.'
 
         def on_top_level_group(node)
           top_level_example_groups =