rubocop-rspec 1.38.1 → 1.43.0

data/lib/rubocop/cop/rspec/factory_bot/create_list.rb

@@ -24,7 +24,8 @@ module RuboCop
         #
         #   # good
         #   3.times { create :user }
-        class CreateList < Cop
+        class CreateList < Base
+          extend AutoCorrector
           include ConfigurableEnforcedStyle
 
           MSG_CREATE_LIST = 'Prefer create_list.'
@@ -43,7 +44,7 @@ module RuboCop
           PATTERN
 
           def_node_matcher :factory_list_call, <<-PATTERN
-            (send ${(const nil? {:FactoryGirl :FactoryBot}) nil?} :create_list (sym $_) (int $_) $...)
+            (send {(const nil? {:FactoryGirl :FactoryBot}) nil?} :create_list (sym _) (int $_) ...)
           PATTERN
 
           def on_block(node)
@@ -51,26 +52,19 @@ module RuboCop
             return unless n_times_block_without_arg?(node)
             return unless contains_only_factory?(node.body)
 
-            add_offense(node.send_node, message: MSG_CREATE_LIST)
+            add_offense(node.send_node, message: MSG_CREATE_LIST) do |corrector|
+              CreateListCorrector.new(node.send_node).call(corrector)
+            end
           end
 
           def on_send(node)
             return unless style == :n_times
 
-            factory_list_call(node) do |_receiver, _factory, count, _|
-              add_offense(
-                node,
-                location: :selector,
-                message: format(MSG_N_TIMES, number: count)
-              )
-            end
-          end
-
-          def autocorrect(node)
-            if style == :create_list
-              CreateListCorrector.new(node)
-            else
-              TimesCorrector.new(node)
+            factory_list_call(node) do |count|
+              message = format(MSG_N_TIMES, number: count)
+              add_offense(node.loc.selector, message: message) do |corrector|
+                TimesCorrector.new(node).call(corrector)
+              end
             end
           end
 
@@ -85,7 +79,7 @@ module RuboCop
           end
 
           # :nodoc
-          class Corrector
+          module Corrector
             private
 
             def build_options_string(options)
@@ -108,14 +102,16 @@ module RuboCop
           end
 
           # :nodoc
-          class TimesCorrector < Corrector
+          class TimesCorrector
+            include Corrector
+
             def initialize(node)
               @node = node
             end
 
             def call(corrector)
               replacement = generate_n_times_block(node)
-              corrector.replace(node.loc.expression, replacement)
+              corrector.replace(node, replacement)
             end
 
             private
@@ -136,7 +132,9 @@ module RuboCop
           end
 
           # :nodoc:
-          class CreateListCorrector < Corrector
+          class CreateListCorrector
+            include Corrector
+
             def initialize(node)
               @node = node.parent
             end
@@ -148,7 +146,7 @@ module RuboCop
                               call_replacement(node)
                             end
 
-              corrector.replace(node.loc.expression, replacement)
+              corrector.replace(node, replacement)
             end
 
             private

data/lib/rubocop/cop/rspec/factory_bot/factory_class_name.rb

@@ -19,7 +19,9 @@ module RuboCop
         #   # good
         #   factory :foo, class: 'Foo' do
         #   end
-        class FactoryClassName < Cop
+        class FactoryClassName < Base
+          extend AutoCorrector
+
           MSG = "Pass '%<class_name>s' string instead of `%<class_name>s` " \
                 'constant.'
           ALLOWED_CONSTANTS = %w[Hash OpenStruct].freeze
@@ -32,13 +34,10 @@ module RuboCop
             class_name(node) do |cn|
               next if allowed?(cn.const_name)
 
-              add_offense(cn, message: format(MSG, class_name: cn.const_name))
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.replace(node.loc.expression, "'#{node.source}'")
+              msg = format(MSG, class_name: cn.const_name)
+              add_offense(cn, message: msg) do |corrector|
+                corrector.replace(cn, "'#{cn.source}'")
+              end
             end
           end
 

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

@@ -3,10 +3,11 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks that spec file paths are consistent with the test subject.
+      # Checks that spec file paths are consistent and well-formed.
       #
-      # Checks the path of the spec file and enforces that it reflects the
-      # described class/module and its optionally called out method.
+      # By default, this checks that spec file paths are consistent with the
+      # test subject and and enforces that it reflects the described
+      # class/module and its optionally called out method.
       #
       # With the configuration option `IgnoreMethods` the called out method will
       # be ignored when determining the enforced path.
@@ -15,6 +16,10 @@ module RuboCop
       # be specified that should not as usual be transformed from CamelCase to
       # snake_case (e.g. 'RuboCop' => 'rubocop' ).
       #
+      # With the configuration option `SpecSuffixOnly` test files will only
+      # be checked to ensure they end in '_spec.rb'. This option disables
+      # checking for consistency in the test subject or test methods.
+      #
       # @example
       #   # bad
       #   whatever_spec.rb         # describe MyClass
@@ -41,42 +46,66 @@ module RuboCop
       #   # good
       #   my_class_spec.rb         # describe MyClass, '#method'
       #
-      class FilePath < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      # @example when configuration is `SpecSuffixOnly: true`
+      #   # good
+      #   whatever_spec.rb         # describe MyClass
+      #
+      #   # good
+      #   my_class_spec.rb         # describe MyClass
+      #
+      #   # good
+      #   my_class_spec.rb         # describe MyClass, '#method'
+      #
+      class FilePath < Base
+        include RuboCop::RSpec::TopLevelGroup
 
         MSG = 'Spec path should end with `%<suffix>s`.'
 
-        def_node_search :const_described?,  '(send _ :describe (const ...) ...)'
-        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
+        def_node_matcher :const_described, <<~PATTERN
+          (block
+            $(send #rspec? _example_group $(const ...) $...) ...
+          )
+        PATTERN
 
-        def on_top_level_describe(node, args)
-          return unless const_described?(node) && single_top_level_describe?
-          return if routing_spec?(args)
+        def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
 
-          glob = glob_for(args)
+        def on_top_level_group(node)
+          return unless top_level_groups.one?
 
-          return if filename_ends_with?(glob)
+          const_described(node) do |send_node, described_class, arguments|
+            next if routing_spec?(arguments)
 
-          add_offense(
-            node,
-            message: format(MSG, suffix: glob)
-          )
+            ensure_correct_file_path(send_node, described_class, arguments)
+          end
         end
 
         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))
+        end
+
         def routing_spec?(args)
           args.any?(&method(:routing_metadata?))
         end
 
-        def glob_for((described_class, method_name))
+        def glob_for(described_class, method_name)
+          return glob_for_spec_suffix_only? if spec_suffix_only?
+
           "#{expected_path(described_class)}#{name_glob(method_name)}*_spec.rb"
         end
 
-        def name_glob(name)
-          return unless name&.str_type?
+        def glob_for_spec_suffix_only?
+          '*_spec.rb'
+        end
+
+        def name_glob(method_name)
+          return unless method_name&.str_type?
 
-          "*#{name.str_content.gsub(/\W/, '')}" unless ignore_methods?
+          "*#{method_name.str_content.gsub(/\W/, '')}" unless ignore_methods?
         end
 
         def expected_path(constant)
@@ -103,12 +132,19 @@ module RuboCop
         end
 
         def filename_ends_with?(glob)
-          File.fnmatch?("*#{glob}", processed_source.buffer.name)
+          filename =
+            RuboCop::PathUtil.relative_path(processed_source.buffer.name)
+              .gsub('../', '')
+          File.fnmatch?("*#{glob}", filename)
         end
 
         def relevant_rubocop_rspec_file?(_file)
           true
         end
+
+        def spec_suffix_only?
+          cop_config['SpecSuffixOnly']
+        end
       end
     end
   end

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

@@ -19,23 +19,19 @@ module RuboCop
       #   # good
       #   describe MyClass do
       #   end
-      class Focus < Cop
+      class Focus < Base
         MSG = 'Focused spec found.'
 
-        focusable =
-          ExampleGroups::GROUPS  +
-          ExampleGroups::SKIPPED +
-          Examples::EXAMPLES     +
-          Examples::SKIPPED      +
-          Examples::PENDING
-
         focused = ExampleGroups::FOCUSED + Examples::FOCUSED
 
-        FOCUSABLE_SELECTORS = focusable.node_pattern_union
+        def_node_matcher :focusable_selector?,
+                         (ExampleGroups::GROUPS + ExampleGroups::SKIPPED +
+                          Examples::EXAMPLES + Examples::SKIPPED +
+                          Examples::PENDING).node_pattern_union
 
         def_node_matcher :metadata, <<-PATTERN
-          {(send #{RSPEC} #{FOCUSABLE_SELECTORS} <$(sym :focus) ...>)
-           (send #{RSPEC} #{FOCUSABLE_SELECTORS} ... (hash <$(pair (sym :focus) true) ...>))}
+          {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
+           (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
         def_node_matcher :focused_block?, focused.send_pattern

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

@@ -57,20 +57,20 @@ module RuboCop
       #   before(:example) do
       #     # ...
       #   end
-      class HookArgument < Cop
+      class HookArgument < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        IMPLICIT_MSG = 'Omit the default `%<scope>p` ' \
-                       'argument for RSpec hooks.'
+        IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
-        HOOKS = Hooks::ALL.node_pattern_union.freeze
+        def_node_matcher :hook?, Hooks::ALL.node_pattern_union
 
         def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send _ #{HOOKS} (sym ${:each :example})) ...)
+          (block $(send _ #hook? (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, "(block $(send _ #{HOOKS}) ...)"
+        def_node_matcher :unscoped_hook, '(block $(send _ #hook?) ...)'
 
         def on_block(node)
           hook(node) do |method_send, scope_name|
@@ -78,18 +78,11 @@ module RuboCop
             return check_implicit(method_send) unless scope_name
 
             style_detected(scope_name)
-            add_offense(
-              method_send,
-              message: explicit_message(scope_name)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          scope = implicit_style? ? '' : "(#{style.inspect})"
-
-          lambda do |corrector|
-            corrector.replace(argument_range(node), scope)
+            msg = explicit_message(scope_name)
+            add_offense(method_send, message: msg) do |corrector|
+              scope = implicit_style? ? '' : "(#{style.inspect})"
+              corrector.replace(argument_range(method_send), scope)
+            end
           end
         end
 
@@ -99,11 +92,11 @@ module RuboCop
           style_detected(:implicit)
           return if implicit_style?
 
-          add_offense(
-            method_send,
-            location: :selector,
-            message: format(EXPLICIT_MSG, scope: style)
-          )
+          msg = explicit_message(nil)
+          add_offense(method_send.loc.selector, message: msg) do |corrector|
+            scope = "(#{style.inspect})"
+            corrector.replace(argument_range(method_send), scope)
+          end
         end
 
         def explicit_message(scope)

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

@@ -23,9 +23,8 @@ module RuboCop
       #     expect(foo).to be
       #   end
       #
-      class HooksBeforeExamples < Cop
-        include RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
+      class HooksBeforeExamples < Base
+        extend AutoCorrector
 
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
@@ -42,17 +41,6 @@ module RuboCop
           check_hooks(node.body) if multiline_block?(node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_example = find_first_example(node.parent)
-            first_example_pos = first_example.loc.expression
-            indent = "\n" + ' ' * first_example.loc.column
-
-            corrector.insert_before(first_example_pos, source(node) + indent)
-            corrector.remove(node_range_with_surrounding_space(node))
-          end
-        end
-
         private
 
         def multiline_block?(block)
@@ -67,10 +55,10 @@ module RuboCop
             next if child.sibling_index < first_example.sibling_index
             next unless hook?(child)
 
-            add_offense(
-              child,
-              message: format(MSG, hook: child.method_name)
-            )
+            msg = format(MSG, hook: child.method_name)
+            add_offense(child, message: msg) do |corrector|
+              autocorrect(corrector, child, first_example)
+            end
           end
         end
 
@@ -78,17 +66,10 @@ module RuboCop
           node.children.find { |sibling| example_or_group?(sibling) }
         end
 
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          node.loc.expression.with(end_pos: final_end_location(node).end_pos)
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
         end
       end
     end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   it 'changes something to a new value' do
       #     expect { do_something }.to change(something).to(new_value)
       #   end
-      class ImplicitBlockExpectation < Cop
+      class ImplicitBlockExpectation < Base
         MSG = 'Avoid implicit block expectations.'
 
         def_node_matcher :lambda?, <<-PATTERN

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

@@ -24,7 +24,8 @@ module RuboCop
       #   # good
       #   it { should be_truthy }
       #
-      class ImplicitExpect < Cop
+      class ImplicitExpect < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<good>s` over `%<bad>s`.'
@@ -54,20 +55,11 @@ module RuboCop
           else
             opposite_style_detected
 
-            add_offense(
-              node,
-              location: source_range,
-              message: offense_message(expectation_source)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            offense     = offending_expect(node)
-            replacement = replacement_source(offense.source)
-
-            corrector.replace(offense, replacement)
+            msg = offense_message(expectation_source)
+            add_offense(source_range, message: msg) do |corrector|
+              replacement = replacement_source(expectation_source)
+              corrector.replace(source_range, replacement)
+            end
           end
         end