rubocop-rspec 1.38.1 → 1.43.0

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)
@@ -238,18 +208,20 @@ module RuboCop
             'is_a?'
           when 'be_an_instance_of', 'be_instance_of', 'an_instance_of'
             'instance_of?'
-          when 'include', 'respond_to'
-            matcher + '?'
+          when 'include'
+            'include?'
+          when 'respond_to'
+            'respond_to?'
           when /^have_(.+)/
             "has_#{Regexp.last_match(1)}?"
           else
-            matcher[/^be_(.+)/, 1] + '?'
+            "#{matcher[/^be_(.+)/, 1]}?"
           end
         end
         # rubocop:enable Metrics/MethodLength
 
         def replacement_matcher(node)
-          case [cop_config['Strict'], node.method_name == :to]
+          case [cop_config['Strict'], node.method?(:to)]
           when [true, true]
             'be(true)'
           when [true, false]
@@ -261,7 +233,6 @@ module RuboCop
           end
         end
       end
-      # rubocop:enable Metrics/ModuleLength
 
       # Prefer using predicate matcher over using predicate method directly.
       #
@@ -277,12 +248,12 @@ module RuboCop
       #   expect(foo).to be_something
       #
       #   # also good - It checks "true" strictly.
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       # @example Strict: false, EnforcedStyle: inflected
       #   # bad
       #   expect(foo.something?).to be_truthy
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       #   # good
       #   expect(foo).to be_something
@@ -300,7 +271,8 @@ module RuboCop
       #
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be_truthy
-      class PredicateMatcher < Cop
+      class PredicateMatcher < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
         include InflectedHelper
         include ExplicitHelper
@@ -318,15 +290,6 @@ module RuboCop
           check_explicit(node) if style == :explicit
         end
 
-        def autocorrect(node)
-          case style
-          when :inflected
-            autocorrect_inflected(node)
-          when :explicit
-            autocorrect_explicit(node)
-          end
-        end
-
         private
 
         # returns args location with whitespace

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

@@ -30,7 +30,8 @@ module RuboCop
         #   it { is_expected.to have_http_status :success }
         #   it { is_expected.to have_http_status :error }
         #
-        class HttpStatus < Cop
+        class HttpStatus < Base
+          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

@@ -23,7 +23,9 @@ module RuboCop
       #     expect(foo).to receive(:bar).at_most(:once)
       #     expect(foo).to receive(:bar).at_most(:twice).times
       #
-      class ReceiveCounts < Cop
+      class ReceiveCounts < Base
+        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

@@ -13,26 +13,26 @@ module RuboCop
       #     # good
       #     expect(foo).not_to receive(:bar)
       #
-      class ReceiveNever < Cop
+      class ReceiveNever < Base
+        extend AutoCorrector
         MSG = 'Use `not_to receive` instead of `never`.'
 
         def_node_search :method_on_stub?, '(send nil? :receive ...)'
 
         def on_send(node)
-          return unless node.method_name == :never && method_on_stub?(node)
+          return unless node.method?(: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_description.rb

@@ -40,7 +40,7 @@ module RuboCop
       #       end
       #     end
       #
-      class RepeatedDescription < Cop
+      class RepeatedDescription < Base
         MSG = "Don't repeat descriptions within an example group."
 
         def on_block(node)

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

@@ -15,7 +15,7 @@ module RuboCop
       #      expect(user).to be_valid
       #    end
       #
-      class RepeatedExample < Cop
+      class RepeatedExample < Base
         MSG = "Don't repeat examples within an example group."
 
         def on_block(node)
@@ -41,7 +41,7 @@ module RuboCop
         def example_signature(example)
           key_parts = [example.metadata, example.implementation]
 
-          if example.definition.method_name == :its
+          if example.definition.method?(:its)
             key_parts << example.definition.arguments
           end
 

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

@@ -34,7 +34,16 @@ module RuboCop
       #      it { cool_predicate }
       #    end
       #
-      class RepeatedExampleGroupBody < Cop
+      #    # 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 < Base
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
         def_node_matcher :several_example_groups?, <<-PATTERN
@@ -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/repeated_example_group_description.rb

@@ -43,7 +43,7 @@ module RuboCop
       #      # example group
       #    end
       #
-      class RepeatedExampleGroupDescription < Cop
+      class RepeatedExampleGroupDescription < Base
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
         def_node_matcher :several_example_groups?, <<-PATTERN

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

@@ -33,49 +33,41 @@ module RuboCop
       #   # also good as the returned value is dynamic
       #   allow(Foo).to receive(:bar) { bar.baz }
       #
-      class ReturnFromStub < Cop
+      class ReturnFromStub < Base
+        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