rubocop-rspec 1.38.0 → 1.42.0

data/lib/rubocop/cop/rspec/rails/http_status.rb

@@ -31,6 +31,7 @@ module RuboCop
         #   it { is_expected.to have_http_status :error }
         #
         class HttpStatus < Cop
+          extend AutoCorrector
           include ConfigurableEnforcedStyle
 
           def_node_matcher :http_status, <<-PATTERN
@@ -42,14 +43,9 @@ module RuboCop
               checker = checker_class.new(ast_node)
               return unless checker.offensive?
 
-              add_offense(checker.node, message: checker.message)
-            end
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              checker = checker_class.new(node)
-              corrector.replace(node.loc.expression, checker.preferred_style)
+              add_offense(checker.node, message: checker.message) do |corrector|
+                corrector.replace(checker.node, checker.preferred_style)
+              end
             end
           end
 
@@ -70,6 +66,7 @@ module RuboCop
                   'to describe HTTP status code.'
 
             attr_reader :node
+
             def initialize(node)
               @node = node
             end
@@ -110,6 +107,7 @@ module RuboCop
             ALLOWED_STATUSES = %i[error success missing redirect].freeze
 
             attr_reader :node
+
             def initialize(node)
               @node = node
             end

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

@@ -24,6 +24,8 @@ module RuboCop
       #     expect(foo).to receive(:bar).at_most(:twice).times
       #
       class ReceiveCounts < Cop
+        extend AutoCorrector
+
         MSG = 'Use `%<alternative>s` instead of `%<original>s`.'
 
         def_node_matcher :receive_counts, <<-PATTERN
@@ -38,27 +40,23 @@ module RuboCop
 
             offending_range = range(node, offending_node)
 
-            add_offense(
-              offending_node,
-              message: message_for(offending_node, offending_range.source),
-              location: offending_range
-            )
+            msg = message_for(offending_node, offending_range.source)
+            add_offense(offending_range, message: msg) do |corrector|
+              autocorrect(corrector, offending_node, offending_range)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = matcher_for(
-              node.method_name,
-              node.first_argument.source.to_i
-            )
+        private
 
-            original = range(node.parent, node)
-            corrector.replace(original, replacement)
-          end
-        end
+        def autocorrect(corrector, node, range)
+          replacement = matcher_for(
+            node.method_name,
+            node.first_argument.source.to_i
+          )
 
-        private
+          corrector.replace(range, replacement)
+        end
 
         def message_for(node, source)
           alternative = matcher_for(

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

@@ -14,6 +14,7 @@ module RuboCop
       #     expect(foo).not_to receive(:bar)
       #
       class ReceiveNever < Cop
+        extend AutoCorrector
         MSG = 'Use `not_to receive` instead of `never`.'
 
         def_node_search :method_on_stub?, '(send nil? :receive ...)'
@@ -21,18 +22,17 @@ module RuboCop
         def on_send(node)
           return unless node.method_name == :never && method_on_stub?(node)
 
-          add_offense(
-            node,
-            location: :selector
-          )
+          add_offense(node.loc.selector) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.selector, 'not_to')
-            range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
-            corrector.remove(range)
-          end
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node.parent.loc.selector, 'not_to')
+          range = node.loc.dot.with(end_pos: node.loc.selector.end_pos)
+          corrector.remove(range)
         end
       end
     end

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

@@ -34,6 +34,15 @@ module RuboCop
       #      it { cool_predicate }
       #    end
       #
+      #    # good
+      #    context Array do
+      #      it { is_expected.to respond_to :each }
+      #    end
+      #
+      #    context Hash do
+      #      it { is_expected.to respond_to :each }
+      #    end
+      #
       class RepeatedExampleGroupBody < Cop
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
@@ -43,6 +52,7 @@ module RuboCop
 
         def_node_matcher :metadata, '(block (send _ _ _ $...) ...)'
         def_node_matcher :body, '(block _ args $...)'
+        def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
 
         def_node_matcher :skip_or_pending?, <<-PATTERN
           (block <(send nil? {:skip :pending}) ...>)
@@ -75,7 +85,7 @@ module RuboCop
         end
 
         def signature_keys(group)
-          [metadata(group), body(group)]
+          [metadata(group), body(group), const_arg(group)]
         end
 
         def message(group, repeats)

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

@@ -34,48 +34,40 @@ module RuboCop
       #   allow(Foo).to receive(:bar) { bar.baz }
       #
       class ReturnFromStub < Cop
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG_AND_RETURN = 'Use `and_return` for static values.'
         MSG_BLOCK = 'Use block for static values.'
 
         def_node_search :contains_stub?, '(send nil? :receive (...))'
+        def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
         def_node_search :and_return_value, <<-PATTERN
           $(send _ :and_return $(...))
         PATTERN
 
         def on_send(node)
-          return unless contains_stub?(node)
           return unless style == :block
+          return unless contains_stub?(node)
 
           check_and_return_call(node)
         end
 
         def on_block(node)
-          return unless contains_stub?(node)
           return unless style == :and_return
+          return unless stub_with_block?(node)
 
           check_block_body(node)
         end
 
-        def autocorrect(node)
-          if style == :block
-            AndReturnCallCorrector.new(node)
-          else
-            BlockBodyCorrector.new(node)
-          end
-        end
-
         private
 
         def check_and_return_call(node)
           and_return_value(node) do |and_return, args|
             unless dynamic?(args)
-              add_offense(
-                and_return,
-                location: :selector,
-                message: MSG_BLOCK
-              )
+              add_offense(and_return.loc.selector, message: MSG_BLOCK) do |corr|
+                AndReturnCallCorrector.new(and_return).call(corr)
+              end
             end
           end
         end
@@ -83,11 +75,9 @@ module RuboCop
         def check_block_body(block)
           body = block.body
           unless dynamic?(body) # rubocop:disable Style/GuardClause
-            add_offense(
-              block,
-              location: :begin,
-              message: MSG_AND_RETURN
-            )
+            add_offense(block.loc.begin, message: MSG_AND_RETURN) do |corrector|
+              BlockBodyCorrector.new(block).call(corrector)
+            end
           end
         end
 
@@ -152,7 +142,7 @@ module RuboCop
             return if heredoc?
 
             corrector.replace(
-              block.loc.expression,
+              block,
               "#{block.send_node.source}.and_return(#{body.source})"
             )
           end

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

@@ -27,6 +27,8 @@ module RuboCop
       #   end
       #
       class ScatteredLet < Cop
+        extend AutoCorrector
+
         MSG = 'Group all let/let! blocks in the example group together.'
 
         def on_block(node)
@@ -44,9 +46,17 @@ module RuboCop
           lets.each_with_index do |node, idx|
             next if node.sibling_index == first_let.sibling_index + idx
 
-            add_offense(node)
+            add_offense(node) do |corrector|
+              RuboCop::RSpec::Corrector::MoveNode.new(
+                node, corrector, processed_source
+              ).move_after(first_let)
+            end
           end
         end
+
+        def find_first_let(node)
+          node.children.find { |child| let?(child) }
+        end
       end
     end
   end

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

@@ -51,6 +51,8 @@ module RuboCop
       #   end
       #
       class SharedContext < Cop
+        extend AutoCorrector
+
         MSG_EXAMPLES = "Use `shared_examples` when you don't "\
                        'define context.'
 
@@ -68,22 +70,14 @@ module RuboCop
 
         def on_block(node)
           context_with_only_examples(node) do
-            add_shared_item_offense(node.send_node, MSG_EXAMPLES)
+            add_offense(node.send_node, message: MSG_EXAMPLES) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_examples')
+            end
           end
 
           examples_with_only_context(node) do
-            add_shared_item_offense(node.send_node, MSG_CONTEXT)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            context_with_only_examples(node.parent) do
-              corrector.replace(node.loc.selector, 'shared_examples')
-            end
-
-            examples_with_only_context(node.parent) do
-              corrector.replace(node.loc.selector, 'shared_context')
+            add_offense(node.send_node, message: MSG_CONTEXT) do |corrector|
+              corrector.replace(node.send_node.loc.selector, 'shared_context')
             end
           end
         end
@@ -97,13 +91,6 @@ module RuboCop
         def examples_with_only_context(node)
           shared_example(node) { yield if context?(node) && !examples?(node) }
         end
-
-        def add_shared_item_offense(node, message)
-          add_offense(
-            node,
-            message: message
-          )
-        end
       end
     end
   end

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

@@ -21,6 +21,8 @@ module RuboCop
       #   include_examples 'foo bar baz'
       #
       class SharedExamples < Cop
+        extend AutoCorrector
+
         def_node_matcher :shared_examples,
                          (SharedGroups::ALL + Includes::ALL).send_pattern
 
@@ -30,14 +32,9 @@ module RuboCop
             next unless ast_node&.sym_type?
 
             checker = Checker.new(ast_node)
-            add_offense(checker.node, message: checker.message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = Checker.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
+            add_offense(checker.node, message: checker.message) do |corrector|
+              corrector.replace(checker.node, checker.preferred_style)
+            end
           end
         end
 
@@ -47,6 +44,7 @@ module RuboCop
                 'to titleize shared examples.'
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end

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

@@ -17,6 +17,8 @@ module RuboCop
       #   allow(foo).to receive("bar.baz")
       #
       class SingleArgumentMessageChain < Cop
+        extend AutoCorrector
+
         MSG = 'Use `%<recommended>s` instead of calling '\
               '`%<called>s` with a single argument.'
 
@@ -30,22 +32,23 @@ module RuboCop
           message_chain(node) do |arg|
             return if valid_usage?(arg)
 
-            add_offense(node, location: :selector)
-          end
-        end
+            method = node.method_name
+            msg = format(MSG, recommended: replacement(method), called: method)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement(node.method_name))
-            message_chain(node) do |arg|
-              autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
-              autocorrect_array_arg(corrector, arg) if arg.array_type?
+            add_offense(node.loc.selector, message: msg) do |corrector|
+              autocorrect(corrector, node, method, arg)
             end
           end
         end
 
         private
 
+        def autocorrect(corrector, node, method, arg)
+          corrector.replace(node.loc.selector, replacement(method))
+          autocorrect_hash_arg(corrector, arg) if single_key_hash?(arg)
+          autocorrect_array_arg(corrector, arg) if arg.array_type?
+        end
+
         def valid_usage?(node)
           return true unless node.literal? || node.array_type?
 
@@ -63,7 +66,7 @@ module RuboCop
         def autocorrect_hash_arg(corrector, arg)
           key, value = *arg.children.first
 
-          corrector.replace(arg.loc.expression, key_to_arg(key))
+          corrector.replace(arg, key_to_arg(key))
           corrector.insert_after(arg.parent.loc.end,
                                  ".and_return(#{value.source})")
         end
@@ -71,7 +74,7 @@ module RuboCop
         def autocorrect_array_arg(corrector, arg)
           value = arg.children.first
 
-          corrector.replace(arg.loc.expression, value.source)
+          corrector.replace(arg, value.source)
         end
 
         def key_to_arg(node)
@@ -82,12 +85,6 @@ module RuboCop
         def replacement(method)
           method.equal?(:receive_message_chain) ? 'receive' : 'stub'
         end
-
-        def message(node)
-          method = node.method_name
-
-          format(MSG, recommended: replacement(method), called: method)
-        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     module RSpec
@@ -20,6 +22,8 @@ module RuboCop
       #   end
       #
       class SubjectStub < Cop
+        include RuboCop::RSpec::TopLevelGroup
+
         MSG = 'Do not stub methods of the object under test.'
 
         # @!method subject(node)
@@ -73,72 +77,40 @@ module RuboCop
             } ...)
         PATTERN
 
-        def on_block(node)
-          return unless example_group?(node)
+        def on_top_level_group(node)
+          @explicit_subjects = find_all_explicit_subjects(node)
 
-          find_subject_stub(node) do |stub|
+          find_subject_expectations(node) do |stub|
             add_offense(stub)
           end
         end
 
         private
 
-        # Find subjects within tree and then find (send) nodes for that subject
-        #
-        # @param node [RuboCop::Node] example group
-        #
-        # @yield [RuboCop::Node] message expectations for subject
-        def find_subject_stub(node, &block)
-          find_subject(node) do |subject_name, context|
-            find_subject_expectation(context, subject_name, &block)
-          end
-        end
-
-        # Find a subject message expectation
-        #
-        # @param node [RuboCop::Node]
-        # @param subject_name [Symbol] name of subject
-        #
-        # @yield [RuboCop::Node] message expectation
-        def find_subject_expectation(node, subject_name, &block)
-          # Do not search node if it is an example group with its own subject.
-          return if example_group?(node) && redefines_subject?(node)
-
-          # Yield the current node if it is a message expectation.
-          yield(node) if message_expectation?(node, subject_name)
+        def find_all_explicit_subjects(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            name = subject(child)
+            next unless name
 
-          # Recurse through node's children looking for a message expectation.
-          node.each_child_node do |child|
-            find_subject_expectation(child, subject_name, &block)
-          end
-        end
+            outer_example_group = child.each_ancestor.find do |a|
+              example_group?(a)
+            end
 
-        # Check if node's children contain a subject definition
-        #
-        # @param node [RuboCop::Node]
-        #
-        # @return [Boolean]
-        def redefines_subject?(node)
-          node.each_child_node.any? do |child|
-            subject(child) || redefines_subject?(child)
+            h[outer_example_group] ||= []
+            h[outer_example_group] << name
           end
         end
 
-        # Find a subject definition
-        #
-        # @param node [RuboCop::Node]
-        # @param parent [RuboCop::Node,nil]
-        #
-        # @yieldparam subject_name [Symbol] name of subject being defined
-        # @yieldparam parent [RuboCop::Node] parent of subject definition
-        def find_subject(node, parent: nil, &block)
-          # An implicit subject is defined by RSpec when no subject is declared
-          subject_name = subject(node) || :subject
+        def find_subject_expectations(node, subject_names = [], &block)
+          subject_names = @explicit_subjects[node] if @explicit_subjects[node]
 
-          yield(subject_name, parent) if parent
+          expectation_detected = (subject_names + [:subject]).any? do |name|
+            message_expectation?(node, name)
+          end
+          return yield(node) if expectation_detected
 
           node.each_child_node do |child|
-            find_subject(child, parent: node, &block)
+            find_subject_expectations(child, subject_names, &block)
           end
         end
       end