rubocop-rspec 1.38.1 → 1.43.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      #  Checks for empty before and after hooks.
+      #
+      # @example
+      #   # bad
+      #   before {}
+      #   after do; end
+      #   before(:all) do
+      #   end
+      #   after(:all) { }
+      #
+      #   # good
+      #   before { create_users }
+      #   after do
+      #     cleanup_users
+      #   end
+      #   before(:all) do
+      #     create_feed
+      #   end
+      #   after(:all) { cleanup_feed }
+      class EmptyHook < Base
+        extend AutoCorrector
+        include RuboCop::Cop::RangeHelp
+
+        MSG = 'Empty hook detected.'
+
+        def_node_matcher :empty_hook?, <<~PATTERN
+          (block $#{Hooks::ALL.send_pattern} _ nil?)
+        PATTERN
+
+        def on_block(node)
+          empty_hook?(node) do |hook|
+            add_offense(hook) do |corrector|
+              range = range_with_surrounding_space(range: node.loc.expression)
+              corrector.remove(range)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -41,20 +41,18 @@ module RuboCop
       #     it { two }
       #   end
       #
-      class EmptyLineAfterExample < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterExample < Base
+        extend AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<example>s`.'
 
         def on_block(node)
           return unless example?(node)
-          return if last_child?(node)
           return if allowed_one_liner?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(node,
-                        location: location,
-                        message: format(MSG, example: node.method_name))
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example: method)
           end
         end
 

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

@@ -23,21 +23,17 @@ module RuboCop
       #     end
       #   end
       #
-      class EmptyLineAfterExampleGroup < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterExampleGroup < Base
+        extend AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<example_group>s`.'
 
         def on_block(node)
           return unless example_group?(node)
-          return if last_child?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(
-              node,
-              location: location,
-              message: format(MSG, example_group: node.method_name)
-            )
+          missing_separating_line_offense(node) do |method|
+            format(MSG, example_group: method)
           end
         end
       end

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

@@ -16,21 +16,21 @@ module RuboCop
       #   let(:something) { other }
       #
       #   it { does_something }
-      class EmptyLineAfterFinalLet < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterFinalLet < Base
+        extend AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
 
-        MSG = 'Add an empty line after the last `let` block.'
+        MSG = 'Add an empty line after the last `%<let>s`.'
 
         def on_block(node)
           return unless example_group_with_body?(node)
 
-          latest_let = node.body.child_nodes.select { |child| let?(child) }.last
+          final_let = node.body.child_nodes.reverse.find { |child| let?(child) }
 
-          return if latest_let.nil?
-          return if last_child?(latest_let)
+          return if final_let.nil?
 
-          missing_separating_line(latest_let) do |location|
-            add_offense(latest_let, location: location)
+          missing_separating_line_offense(final_let) do |method|
+            format(MSG, let: method)
           end
         end
       end

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

@@ -33,21 +33,17 @@ module RuboCop
       #
       #   it { does_something }
       #
-      class EmptyLineAfterHook < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterHook < Base
+        extend AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
 
         MSG = 'Add an empty line after `%<hook>s`.'
 
         def on_block(node)
           return unless hook?(node)
-          return if last_child?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(
-              node,
-              location: location,
-              message: format(MSG, hook: node.method_name)
-            )
+          missing_separating_line_offense(node) do |method|
+            format(MSG, hook: method)
           end
         end
       end

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

@@ -14,17 +14,17 @@ module RuboCop
       #   subject(:obj) { described_class }
       #
       #   let(:foo) { bar }
-      class EmptyLineAfterSubject < Cop
-        include RuboCop::RSpec::BlankLineSeparation
+      class EmptyLineAfterSubject < Base
+        extend AutoCorrector
+        include RuboCop::RSpec::EmptyLineSeparation
 
-        MSG = 'Add empty line after `subject`.'
+        MSG = 'Add an empty line after `%<subject>s`.'
 
         def on_block(node)
           return unless subject?(node) && !in_spec_block?(node)
-          return if last_child?(node)
 
-          missing_separating_line(node) do |location|
-            add_offense(node, location: location)
+          missing_separating_line_offense(node) do |method|
+            format(MSG, subject: method)
           end
         end
 

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

@@ -25,7 +25,7 @@ module RuboCop
       #     result = service.call
       #     expect(result).to be(true)
       #   end
-      class ExampleLength < Cop
+      class ExampleLength < Base
         include CodeLength
 
         MSG = 'Example has too many lines [%<total>d/%<max>d].'

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

@@ -47,7 +47,7 @@ module RuboCop
       #     result = service.call
       #     expect(result).to be(true)
       #   end
-      class ExampleWithoutDescription < Cop
+      class ExampleWithoutDescription < Base
         include ConfigurableEnforcedStyle
 
         MSG_DEFAULT_ARGUMENT = 'Omit the argument when you want to ' \

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

@@ -29,7 +29,9 @@ module RuboCop
       #   # good
       #   it 'does things' do
       #   end
-      class ExampleWording < Cop
+      class ExampleWording < Base
+        extend AutoCorrector
+
         MSG_SHOULD = 'Do not use should when describing your tests.'
         MSG_IT     = "Do not repeat 'it' when describing your tests."
 
@@ -45,24 +47,21 @@ module RuboCop
 
         def on_block(node)
           it_description(node) do |description_node, message|
-            if message =~ SHOULD_PREFIX
+            if message.match?(SHOULD_PREFIX)
               add_wording_offense(description_node, MSG_SHOULD)
-            elsif message =~ IT_PREFIX
+            elsif message.match?(IT_PREFIX)
               add_wording_offense(description_node, MSG_IT)
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(docstring(node), replacement_text(node))
-          end
-        end
-
         private
 
         def add_wording_offense(node, message)
-          add_offense(node, location: docstring(node), message: message)
+          docstring = docstring(node)
+          add_offense(docstring, message: message) do |corrector|
+            corrector.replace(docstring, replacement_text(node))
+          end
         end
 
         def docstring(node)
@@ -78,7 +77,7 @@ module RuboCop
         def replacement_text(node)
           text = text(node)
 
-          if text =~ SHOULD_PREFIX
+          if text.match?(SHOULD_PREFIX)
             RuboCop::RSpec::Wording.new(
               text,
               ignore:  ignored_words,

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

@@ -16,7 +16,9 @@ module RuboCop
       #   expect(pattern).to eq(/foo/)
       #   expect(name).to eq("John")
       #
-      class ExpectActual < Cop
+      class ExpectActual < Base
+        extend AutoCorrector
+
         MSG = 'Provide the actual you are testing to `expect(...)`.'
 
         SIMPLE_LITERALS = %i[
@@ -55,17 +57,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          expect_literal(node) do |argument|
-            add_offense(node, location: argument.source_range)
-          end
-        end
-
-        def autocorrect(node)
-          actual, matcher, expected = expect_literal(node)
-          lambda do |corrector|
-            return unless SUPPORTED_MATCHERS.include?(matcher)
+          expect_literal(node) do |actual, matcher, expected|
+            add_offense(actual.source_range) do |corrector|
+              next unless SUPPORTED_MATCHERS.include?(matcher)
 
-            swap(corrector, actual, expected)
+              swap(corrector, actual, expected)
+            end
           end
         end
 

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

@@ -29,7 +29,8 @@ module RuboCop
       #   expect { run }.to change { Foo.bar(:count) }
       #   expect { run }.to change { user.reload.name }
       #
-      class ExpectChange < Cop
+      class ExpectChange < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG_BLOCK = 'Prefer `change(%<obj>s, :%<attr>s)`.'
@@ -51,10 +52,11 @@ module RuboCop
           return unless style == :block
 
           expect_change_with_arguments(node) do |receiver, message|
-            add_offense(
-              node,
-              message: format(MSG_CALL, obj: receiver, attr: message)
-            )
+            msg = format(MSG_CALL, obj: receiver, attr: message)
+            add_offense(node, message: msg) do |corrector|
+              replacement = "change { #{receiver}.#{message} }"
+              corrector.replace(node, replacement)
+            end
           end
         end
 
@@ -62,37 +64,10 @@ module RuboCop
           return unless style == :method_call
 
           expect_change_with_block(node) do |receiver, message|
-            add_offense(
-              node,
-              message: format(MSG_BLOCK, obj: receiver, attr: message)
-            )
-          end
-        end
-
-        def autocorrect(node)
-          if style == :block
-            autocorrect_method_call_to_block(node)
-          else
-            autocorrect_block_to_method_call(node)
-          end
-        end
-
-        private
-
-        def autocorrect_method_call_to_block(node)
-          lambda do |corrector|
-            expect_change_with_arguments(node) do |receiver, message|
-              replacement = "change { #{receiver}.#{message} }"
-              corrector.replace(node.loc.expression, replacement)
-            end
-          end
-        end
-
-        def autocorrect_block_to_method_call(node)
-          lambda do |corrector|
-            expect_change_with_block(node) do |receiver, message|
+            msg = format(MSG_BLOCK, obj: receiver, attr: message)
+            add_offense(node, message: msg) do |corrector|
               replacement = "change(#{receiver}, :#{message})"
-              corrector.replace(node.loc.expression, replacement)
+              corrector.replace(node, replacement)
             end
           end
         end

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

@@ -20,7 +20,7 @@ module RuboCop
       #   it do
       #     expect(something).to eq 'foo'
       #   end
-      class ExpectInHook < Cop
+      class ExpectInHook < Base
         MSG = 'Do not use `%<expect>s` in `%<hook>s` hook'
 
         def_node_search :expectation, Expectations::ALL.send_pattern
@@ -30,8 +30,8 @@ module RuboCop
           return if node.body.nil?
 
           expectation(node.body) do |expect|
-            add_offense(expect, location: :selector,
-                                message: message(expect, node))
+            add_offense(expect.loc.selector,
+                        message: message(expect, node))
           end
         end
 

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

@@ -14,7 +14,7 @@ module RuboCop
       #
       #   # good
       #   expect { my_app.print_report }.to output('Hello World').to_stdout
-      class ExpectOutput < Cop
+      class ExpectOutput < Base
         MSG = 'Use `expect { ... }.to output(...).to_%<name>s` '\
               'instead of mutating $%<name>s.'
 
@@ -27,7 +27,7 @@ module RuboCop
           name = variable_name[1..-1]
           return unless name.eql?('stdout') || name.eql?('stderr')
 
-          add_offense(node, location: :name, message: format(MSG, name: name))
+          add_offense(node.loc.name, message: format(MSG, name: name))
         end
 
         private

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

@@ -24,36 +24,43 @@ module RuboCop
         #
         #   # good
         #   count { 1 }
-        class AttributeDefinedStatically < Cop
+        class AttributeDefinedStatically < Base
+          extend AutoCorrector
+
           MSG = 'Use a block to declare attribute values.'
 
           def_node_matcher :value_matcher, <<-PATTERN
             (send _ !#reserved_method? $...)
           PATTERN
 
-          def_node_search :factory_attributes, <<-PATTERN
+          def_node_matcher :factory_attributes, <<-PATTERN
             (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
           PATTERN
 
           def on_block(node)
-            factory_attributes(node).to_a.flatten.each do |attribute|
+            attributes = factory_attributes(node) || []
+            attributes = [attributes] unless attributes.is_a?(Array) # rubocop:disable Style/ArrayCoercion, Lint/RedundantCopDisableDirective
+
+            attributes.each do |attribute|
               next unless offensive_receiver?(attribute.receiver, node)
               next if proc?(attribute) || association?(attribute.first_argument)
 
-              add_offense(attribute)
+              add_offense(attribute) do |corrector|
+                autocorrect(corrector, attribute)
+              end
             end
           end
 
-          def autocorrect(node)
+          private
+
+          def autocorrect(corrector, node)
             if node.parenthesized?
-              autocorrect_replacing_parens(node)
+              autocorrect_replacing_parens(corrector, node)
             else
-              autocorrect_without_parens(node)
+              autocorrect_without_parens(corrector, node)
             end
           end
 
-          private
-
           def offensive_receiver?(receiver, node)
             receiver.nil? ||
               receiver.self_type? ||
@@ -74,24 +81,20 @@ module RuboCop
 
           def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
 
-          def autocorrect_replacing_parens(node)
+          def autocorrect_replacing_parens(corrector, node)
             left_braces, right_braces = braces(node)
 
-            lambda do |corrector|
-              corrector.replace(node.location.begin, ' ' + left_braces)
-              corrector.replace(node.location.end, right_braces)
-            end
+            corrector.replace(node.location.begin, " #{left_braces}")
+            corrector.replace(node.location.end, right_braces)
           end
 
-          def autocorrect_without_parens(node)
+          def autocorrect_without_parens(corrector, node)
             left_braces, right_braces = braces(node)
 
-            lambda do |corrector|
-              argument = node.first_argument
-              expression = argument.location.expression
-              corrector.insert_before(expression, left_braces)
-              corrector.insert_after(expression, right_braces)
-            end
+            argument = node.first_argument
+            expression = argument.location.expression
+            corrector.insert_before(expression, left_braces)
+            corrector.insert_after(expression, right_braces)
           end
 
           def braces(node)