rubocop-rspec 1.41.0 → 1.44.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

@@ -56,35 +56,43 @@ module RuboCop
       #   # good
       #   my_class_spec.rb         # describe MyClass, '#method'
       #
-      class FilePath < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      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_matcher :const_described, <<~PATTERN
+          (block
+            $(send #rspec? _example_group $(const ...) $...) ...
+          )
+        PATTERN
+
         def_node_search :routing_metadata?, '(pair (sym :type) (sym :routing))'
 
-        def on_top_level_describe(node, args)
-          return unless const_described?(node) && single_top_level_describe?
-          return if routing_spec?(args)
+        def on_top_level_example_group(node)
+          return unless top_level_groups.one?
 
-          glob = glob_for(args)
+          const_described(node) do |send_node, described_class, arguments|
+            next if routing_spec?(arguments)
 
-          return if filename_ends_with?(glob)
-
-          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"
@@ -94,10 +102,10 @@ module RuboCop
           '*_spec.rb'
         end
 
-        def name_glob(name)
-          return unless name&.str_type?
+        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)

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,7 +23,9 @@ module RuboCop
       #     expect(foo).to be
       #   end
       #
-      class HooksBeforeExamples < Cop
+      class HooksBeforeExamples < Base
+        extend AutoCorrector
+
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
         def_node_matcher :example_or_group?, <<-PATTERN
@@ -39,15 +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)
-            RuboCop::RSpec::Corrector::MoveNode.new(
-              node, corrector, processed_source
-            ).move_before(first_example)
-          end
-        end
-
         private
 
         def multiline_block?(block)
@@ -62,16 +55,22 @@ 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
 
         def find_first_example(node)
           node.children.find { |sibling| example_or_group?(sibling) }
         end
+
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
+        end
       end
     end
   end

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

@@ -16,14 +16,13 @@ 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
           {
             (send (const nil? :Proc) :new)
-            (send nil? :proc)
-            (send nil? :lambda)
+            (send nil? {:proc :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
 

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

@@ -26,7 +26,8 @@ module RuboCop
       #   # good
       #   it { expect(subject).to be_truthy }
       #
-      class ImplicitSubject < Cop
+      class ImplicitSubject < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = "Don't use implicit subject."
@@ -39,33 +40,37 @@ module RuboCop
           return unless implicit_subject?(node)
           return if valid_usage?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = 'expect(subject)'
-          if node.method_name == :should
+          case node.method_name
+          when :should
             replacement += '.to'
-          elsif node.method_name == :should_not
+          when :should_not
             replacement += '.not_to'
           end
 
-          ->(corrector) { corrector.replace(node.loc.selector, replacement) }
+          corrector.replace(node.loc.selector, replacement)
         end
 
-        private
-
         def valid_usage?(node)
           example = node.ancestors.find { |parent| example?(parent) }
           return false if example.nil?
 
-          example.method_name == :its || allowed_by_style?(example)
+          example.method?(:its) || allowed_by_style?(example)
         end
 
         def allowed_by_style?(example)
-          if style == :single_line_only
+          case style
+          when :single_line_only
             example.single_line?
-          elsif style == :single_statement_only
+          when :single_statement_only
             !example.body.begin_type?
           else
             false