rubocop-rspec 1.41.0 → 1.42.0

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

@@ -25,6 +25,7 @@ module RuboCop
       #   it { should be_truthy }
       #
       class ImplicitExpect < Cop
+        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

@@ -27,6 +27,7 @@ module RuboCop
       #   it { expect(subject).to be_truthy }
       #
       class ImplicitSubject < Cop
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = "Don't use implicit subject."
@@ -39,10 +40,14 @@ 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
             replacement += '.to'
@@ -50,11 +55,9 @@ module RuboCop
             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?

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

@@ -19,6 +19,8 @@ module RuboCop
       #   end
       #
       class InstanceSpy < Cop
+        extend AutoCorrector
+
         MSG = 'Use `instance_spy` when you check your double '\
               'with `have_received`.'
 
@@ -43,22 +45,26 @@ module RuboCop
 
           null_double(node) do |var, receiver|
             have_received_usage(node) do |expected|
-              add_offense(receiver) if expected == var
+              next if expected != var
+
+              add_offense(receiver) do |corrector|
+                autocorrect(corrector, receiver)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = 'instance_spy'
-            corrector.replace(node.loc.selector, replacement)
+        private
 
-            double_source_map = node.parent.loc
-            as_null_object_range = double_source_map
-              .dot
-              .join(double_source_map.selector)
-            corrector.remove(as_null_object_range)
-          end
+        def autocorrect(corrector, node)
+          replacement = 'instance_spy'
+          corrector.replace(node.loc.selector, replacement)
+
+          double_source_map = node.parent.loc
+          as_null_object_range = double_source_map
+            .dot
+            .join(double_source_map.selector)
+          corrector.remove(as_null_object_range)
         end
       end
     end

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

@@ -24,7 +24,8 @@ module RuboCop
 
         def on_send(node)
           invalid_predicate_matcher?(node) do |predicate|
-            add_offense(predicate)
+            add_offense(predicate,
+                        message: format(MSG, matcher: predicate.method_name))
           end
         end
 
@@ -34,10 +35,6 @@ module RuboCop
           name = name.to_s
           name.start_with?('be_', 'have_') && name.end_with?('?')
         end
-
-        def message(predicate)
-          format(MSG, matcher: predicate.method_name)
-        end
       end
     end
   end

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

@@ -19,6 +19,7 @@ module RuboCop
       #   # good
       #   it_should_behave_like 'a foo'
       class ItBehavesLike < Cop
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s` when including '\
@@ -28,14 +29,12 @@ module RuboCop
 
         def on_send(node)
           example_inclusion_offense(node, alternative_style) do
-            add_offense(node)
+            add_offense(node) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)

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

@@ -32,6 +32,8 @@ module RuboCop
       #     it { expect_something_else }
       #
       class LeadingSubject < Cop
+        extend AutoCorrector
+
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
         def on_block(node)
@@ -43,27 +45,25 @@ module RuboCop
         def check_previous_nodes(node)
           node.parent.each_child_node do |sibling|
             if offending?(sibling)
-              add_offense(
-                node,
-                message: format(MSG, offending: sibling.method_name)
-              )
+              msg = format(MSG, offending: sibling.method_name)
+              add_offense(node, message: msg) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
 
             break if offending?(sibling) || sibling.equal?(node)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_node = find_first_offending_node(node)
-            RuboCop::RSpec::Corrector::MoveNode.new(
-              node, corrector, processed_source
-            ).move_before(first_node)
-          end
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          first_node = find_first_offending_node(node)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_node)
+        end
+
         def offending?(node)
           let?(node) || hook?(node) || example?(node)
         end

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

@@ -31,6 +31,8 @@ module RuboCop
       #     expect(some).to be
       #   end
       class LetBeforeExamples < Cop
+        extend AutoCorrector
+
         MSG = 'Move `let` before the examples in the group.'
 
         def_node_matcher :example_or_group?, <<-PATTERN
@@ -46,15 +48,6 @@ module RuboCop
           check_let_declarations(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)
@@ -67,14 +60,23 @@ module RuboCop
 
           node.each_child_node do |child|
             next if child.sibling_index < first_example.sibling_index
+            next unless let?(child)
 
-            add_offense(child) if let?(child)
+            add_offense(child) 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/message_chain.rb

@@ -21,11 +21,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          message_chain(node) { add_offense(node, location: :selector) }
-        end
-
-        def message(node)
-          format(MSG, method: node.method_name)
+          message_chain(node) do
+            add_offense(
+              node.loc.selector,
+              message: format(MSG, method: node.method_name)
+            )
+          end
         end
       end
     end

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

@@ -42,7 +42,7 @@ module RuboCop
             return correct_style_detected if preferred_style?(match)
 
             message = format(MSG, style: style)
-            add_offense(match, location: :selector, message: message) do
+            add_offense(match.loc.selector, message: message) do
               opposite_style_detected
             end
           end

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

@@ -48,8 +48,7 @@ module RuboCop
             return correct_style_detected if preferred_style?(message_matcher)
 
             add_offense(
-              message_matcher,
-              location: :selector,
+              message_matcher.loc.selector,
               message: error_message(receiver)
             ) { opposite_style_detected }
           end

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

@@ -34,6 +34,7 @@ module RuboCop
       #     This is enough of an edge case that people can just move this to
       #     a `before` hook on their own
       class MultipleSubjects < Cop
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Do not set more than one subject per example group'
@@ -44,38 +45,36 @@ module RuboCop
           subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
 
           subjects[0...-1].each do |subject|
-            add_offense(subject)
+            add_offense(subject) do |corrector|
+              autocorrect(corrector, subject)
+            end
           end
         end
 
-        def autocorrect(node)
-          return unless node.method_name.equal?(:subject) # Ignore `subject!`
+        private
+
+        def autocorrect(corrector, subject)
+          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
 
-          if named_subject?(node)
-            rename_autocorrect(node)
+          if named_subject?(subject)
+            rename_autocorrect(corrector, subject)
           else
-            remove_autocorrect(node)
+            remove_autocorrect(corrector, subject)
           end
         end
 
-        private
-
         def named_subject?(node)
           node.send_node.arguments?
         end
 
-        def rename_autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'let')
-          end
+        def rename_autocorrect(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'let')
         end
 
-        def remove_autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(node.source_range,
-                                         include_final_newline: true)
-            corrector.remove(range)
-          end
+        def remove_autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range,
+                                       include_final_newline: true)
+          corrector.remove(range)
         end
       end
     end

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

@@ -62,7 +62,7 @@ module RuboCop
           return if !rspec_block?(node) || ignored_shared_example?(node)
 
           subject_usage(node) do |subject_node|
-            add_offense(subject_node, location: :selector)
+            add_offense(subject_node.loc.selector)
           end
         end
 

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

@@ -16,6 +16,7 @@ module RuboCop
       #     expect(false).not_to be_true
       #   end
       class NotToNot < Cop
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
@@ -24,14 +25,12 @@ module RuboCop
 
         def on_send(node)
           not_to_not_offense(node, alternative_style) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)

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

@@ -14,11 +14,14 @@ module RuboCop
         private
 
         def check_inflected(node)
-          predicate_in_actual?(node) do |predicate|
-            add_offense(
-              node,
-              message: message_inflected(predicate)
-            )
+          predicate_in_actual?(node) do |predicate, to, matcher|
+            msg = message_inflected(predicate)
+            add_offense(node, message: msg) do |corrector|
+              remove_predicate(corrector, predicate)
+              corrector.replace(node.loc.selector,
+                                true?(to, matcher) ? 'to' : 'not_to')
+              rewrite_matcher(corrector, predicate, matcher)
+            end
           end
         end
 
@@ -76,17 +79,6 @@ module RuboCop
         end
         # rubocop:enable Metrics/MethodLength
 
-        def autocorrect_inflected(node)
-          predicate_in_actual?(node) do |predicate, to, matcher|
-            lambda do |corrector|
-              remove_predicate(corrector, predicate)
-              corrector.replace(node.loc.selector,
-                                true?(to, matcher) ? 'to' : 'not_to')
-              rewrite_matcher(corrector, predicate, matcher)
-            end
-          end
-        end
-
         def remove_predicate(corrector, predicate)
           range = predicate.loc.dot.with(
             end_pos: predicate.loc.expression.end_pos
@@ -123,7 +115,6 @@ module RuboCop
       end
 
       # A helper for `explicit` style
-      # rubocop:disable Metrics/ModuleLength
       module ExplicitHelper
         include RuboCop::RSpec::Language
         extend NodePattern::Macros
@@ -143,22 +134,21 @@ module RuboCop
         end
 
         def check_explicit(node) # rubocop:disable Metrics/MethodLength
-          predicate_matcher_block?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher_block?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              to_node = node.send_node
+              corrector_explicit(corrector, to_node, actual, matcher, to_node)
+            end
             ignore_node(node.children.first)
             return
           end
 
           return if part_of_ignored_node?(node)
 
-          predicate_matcher?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              corrector_explicit(corrector, node, actual, matcher, matcher)
+            end
           end
         end
 
@@ -193,31 +183,11 @@ module RuboCop
                  matcher_name: matcher.method_name)
         end
 
-        def autocorrect_explicit(node)
-          autocorrect_explicit_send(node) ||
-            autocorrect_explicit_block(node)
-        end
-
-        def autocorrect_explicit_send(node)
-          predicate_matcher?(node) do |actual, matcher|
-            corrector_explicit(node, actual, matcher, matcher)
-          end
-        end
-
-        def autocorrect_explicit_block(node)
-          predicate_matcher_block?(node) do |actual, matcher|
-            to_node = node.send_node
-            corrector_explicit(to_node, actual, matcher, to_node)
-          end
-        end
-
-        def corrector_explicit(to_node, actual, matcher, block_child)
-          lambda do |corrector|
-            replacement_matcher = replacement_matcher(to_node)
-            corrector.replace(matcher.loc.expression, replacement_matcher)
-            move_predicate(corrector, actual, matcher, block_child)
-            corrector.replace(to_node.loc.selector, 'to')
-          end
+        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
+          replacement_matcher = replacement_matcher(to_node)
+          corrector.replace(matcher.loc.expression, replacement_matcher)
+          move_predicate(corrector, actual, matcher, block_child)
+          corrector.replace(to_node.loc.selector, 'to')
         end
 
         def move_predicate(corrector, actual, matcher, block_child)
@@ -261,7 +231,6 @@ module RuboCop
           end
         end
       end
-      # rubocop:enable Metrics/ModuleLength
 
       # Prefer using predicate matcher over using predicate method directly.
       #
@@ -301,6 +270,7 @@ module RuboCop
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be_truthy
       class PredicateMatcher < Cop
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
         include InflectedHelper
         include ExplicitHelper