rubocop-rspec 2.18.0 → 2.19.0

data/lib/rubocop/cop/rspec/mixin/location_help.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods to location.
+      module LocationHelp
+        module_function
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Parser::Source::Range]
+        # @example
+        #   foo 1, 2
+        #      ^^^^^
+        def arguments_with_whitespace(node)
+          node.loc.selector.end.with(
+            end_pos: node.source_range.end_pos
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Parser::Source::Range]
+        # @example
+        #   foo { bar }
+        #      ^^^^^^^^
+        def block_with_whitespace(node)
+          return unless (parent = node.parent)
+          return unless parent.block_type?
+
+          node.source_range.end.with(
+            end_pos: parent.source_range.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/mixin/skip_or_pending.rb

@@ -10,13 +10,29 @@ module RuboCop
         # @!method skipped_in_metadata?(node)
         def_node_matcher :skipped_in_metadata?, <<-PATTERN
           {
-            (send _ _ <#skip_or_pending? ...>)
-            (send _ _ ... (hash <(pair #skip_or_pending? { true str dstr }) ...>))
+            (send _ _ <(sym {:skip :pending}) ...>)
+            (send _ _ ... (hash <(pair (sym {:skip :pending}) { true str dstr }) ...>))
           }
         PATTERN
 
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
+        # @!method skip_or_pending_inside_block?(node)
+        #   Match skip/pending statements inside a block (e.g. `context`)
+        #
+        #   @example source that matches
+        #     context 'when color is blue' do
+        #       skip 'not implemented yet'
+        #       pending 'not implemented yet'
+        #     end
+        #
+        #   @example source that does not match
+        #     skip 'not implemented yet'
+        #     pending 'not implemented yet'
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :skip_or_pending_inside_block?, <<-PATTERN
+          (block <(send nil? {:skip :pending} ...) ...>)
+        PATTERN
       end
     end
   end

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

@@ -78,7 +78,8 @@ module RuboCop
         PATTERN
 
         # @!method expect?(node)
-        def_node_matcher :expect?, send_pattern('#Expectations.all')
+        def_node_matcher :expect?, '(send nil? #Expectations.all ...)'
+
         # @!method aggregate_failures_block?(node)
         def_node_matcher :aggregate_failures_block?, <<-PATTERN
           (block (send nil? :aggregate_failures ...) ...)

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

@@ -82,12 +82,14 @@ module RuboCop
         MSG = 'Name your test subject if you need to reference it explicitly.'
 
         # @!method example_or_hook_block?(node)
-        def_node_matcher :example_or_hook_block?,
-                         block_pattern('{#Examples.all #Hooks.all}')
+        def_node_matcher :example_or_hook_block?, <<~PATTERN
+          (block (send nil? {#Examples.all #Hooks.all} ...) ...)
+        PATTERN
 
         # @!method shared_example?(node)
-        def_node_matcher :shared_example?,
-                         block_pattern('#SharedGroups.examples')
+        def_node_matcher :shared_example?, <<~PATTERN
+          (block (send #rspec? #SharedGroups.examples ...) ...)
+        PATTERN
 
         # @!method subject_usage(node)
         def_node_search :subject_usage, '$(send nil? :subject)'

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

@@ -65,10 +65,7 @@ module RuboCop
         # @param [RuboCop::AST::Node] node
         # @return [Boolean]
         def_node_matcher :regular_or_focused_example?, <<~PATTERN
-          {
-            #{block_pattern('{#Examples.regular | #Examples.focused}')}
-            #{numblock_pattern('{#Examples.regular | #Examples.focused}')}
-          }
+          ({block numblock} (send nil? {#Examples.regular #Examples.focused} ...) ...)
         PATTERN
 
         # @!method includes_expectation?(node)
@@ -76,7 +73,7 @@ module RuboCop
         # @return [Boolean]
         def_node_search :includes_expectation?, <<~PATTERN
           {
-            #{send_pattern('#Expectations.all')}
+            (send nil? #Expectations.all ...)
             (send nil? `#matches_allowed_pattern? ...)
           }
         PATTERN

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

@@ -26,7 +26,9 @@ module RuboCop
         MSG = '`%<name>s` is already defined.'
 
         # @!method setup?(node)
-        def_node_matcher :setup?, block_pattern('{#Helpers.all #Subjects.all}')
+        def_node_matcher :setup?, <<~PATTERN
+          (block (send nil? {#Helpers.all #Subjects.all} ...) ...)
+        PATTERN
 
         # @!method first_argument_name(node)
         def_node_matcher :first_argument_name, '(send _ _ ({str sym} $_))'

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

@@ -38,20 +38,20 @@ module RuboCop
         MSG = 'Pending spec found.'
 
         # @!method skippable?(node)
-        def_node_matcher :skippable?,
-                         send_pattern(<<~PATTERN)
-                           {#ExampleGroups.regular #Examples.regular}
-                         PATTERN
+        def_node_matcher :skippable?, <<~PATTERN
+          {
+            (send #rspec? #ExampleGroups.regular ...)
+            (send nil? #Examples.regular ...)
+          }
+        PATTERN
 
         # @!method pending_block?(node)
-        def_node_matcher :pending_block?,
-                         send_pattern(<<~PATTERN)
-                           {
-                             #ExampleGroups.skipped
-                             #Examples.skipped
-                             #Examples.pending
-                           }
-                         PATTERN
+        def_node_matcher :pending_block?, <<~PATTERN
+          {
+            (send #rspec? #ExampleGroups.skipped ...)
+            (send nil? {#Examples.skipped #Examples.pending} ...)
+          }
+        PATTERN
 
         def on_send(node)
           return unless pending_block?(node) || skipped?(node)

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

@@ -59,61 +59,90 @@ module RuboCop
       class PendingWithoutReason < Base
         MSG = 'Give the reason for pending or skip.'
 
-        # @!method pending_by_example_method?(node)
-        def_node_matcher :pending_by_example_method?, block_pattern(<<~PATTERN)
-          #Examples.pending
+        # @!method skipped_in_example?(node)
+        def_node_matcher :skipped_in_example?, <<~PATTERN
+          {
+            (send nil? ${#Examples.skipped #Examples.pending})
+            (block (send nil? ${#Examples.skipped}) ...)
+            (numblock (send nil? ${#Examples.skipped}) ...)
+          }
         PATTERN
 
-        # @!method pending_by_metadata_without_reason?(node)
-        def_node_matcher :pending_by_metadata_without_reason?, <<~PATTERN
-          (send #rspec? {#ExampleGroups.all #Examples.all} ... {<(sym :pending) ...> (hash <(pair (sym :pending) true) ...>)})
+        # @!method skipped_by_example_method?(node)
+        def_node_matcher :skipped_by_example_method?, <<~PATTERN
+          (send nil? ${#Examples.skipped #Examples.pending} ...)
         PATTERN
 
-        # @!method skipped_by_example_method?(node)
-        def_node_matcher :skipped_by_example_method?, block_pattern(<<~PATTERN)
-          #Examples.skipped
+        # @!method metadata_without_reason?(node)
+        def_node_matcher :metadata_without_reason?, <<~PATTERN
+          (send #rspec?
+            {#ExampleGroups.all #Examples.all} ...
+            {
+              <(sym ${:pending :skip}) ...>
+              (hash <(pair (sym ${:pending :skip}) true) ...>)
+            }
+          )
         PATTERN
 
         # @!method skipped_by_example_group_method?(node)
-        def_node_matcher(
-          :skipped_by_example_group_method?,
-          block_pattern(<<~PATTERN)
-            #ExampleGroups.skipped
-          PATTERN
-        )
-
-        # @!method skipped_by_metadata_without_reason?(node)
-        def_node_matcher :skipped_by_metadata_without_reason?, <<~PATTERN
-          (send #rspec? {#ExampleGroups.all #Examples.all} ... {<(sym :skip) ...> (hash <(pair (sym :skip) true) ...>)})
+        def_node_matcher :skipped_by_example_group_method?, <<~PATTERN
+          (send #rspec? ${#ExampleGroups.skipped} ...)
         PATTERN
 
-        # @!method without_reason?(node)
-        def_node_matcher :without_reason?, <<~PATTERN
-          (send nil? ${:pending :skip})
+        # @!method pending_step_without_reason?(node)
+        def_node_matcher :pending_step_without_reason?, <<~PATTERN
+          (send nil? {:skip :pending})
         PATTERN
 
         def on_send(node)
-          if pending_without_reason?(node)
-            add_offense(node, message: 'Give the reason for pending.')
-          elsif skipped_without_reason?(node)
-            add_offense(node, message: 'Give the reason for skip.')
-          elsif without_reason?(node) && example?(node.parent)
-            add_offense(node,
-                        message: "Give the reason for #{node.method_name}.")
+          on_pending_by_metadata(node)
+          return unless (parent = parent_node(node))
+
+          if example_group?(parent) || block_node_example_group?(node)
+            on_skipped_by_example_method(node)
+            on_skipped_by_example_group_method(node)
+          elsif example?(parent)
+            on_skipped_by_in_example_method(node, parent)
           end
         end
 
         private
 
-        def pending_without_reason?(node)
-          pending_by_example_method?(node.block_node) ||
-            pending_by_metadata_without_reason?(node)
+        def parent_node(node)
+          node_or_block = node.block_node || node
+          return unless (parent = node_or_block.parent)
+
+          parent.begin_type? && parent.parent ? parent.parent : parent
+        end
+
+        def block_node_example_group?(node)
+          node.block_node &&
+            example_group?(node.block_node) &&
+            explicit_rspec?(node.receiver)
+        end
+
+        def on_skipped_by_in_example_method(node, _direct_parent)
+          skipped_in_example?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
         end
 
-        def skipped_without_reason?(node)
-          skipped_by_example_group_method?(node.block_node) ||
-            skipped_by_example_method?(node.block_node) ||
-            skipped_by_metadata_without_reason?(node)
+        def on_pending_by_metadata(node)
+          metadata_without_reason?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_method(node)
+          skipped_by_example_method?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_skipped_by_example_group_method(node)
+          skipped_by_example_group_method?(node) do
+            add_offense(node, message: 'Give the reason for skip.')
+          end
         end
       end
     end

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

@@ -84,22 +84,22 @@ module RuboCop
 
         def remove_predicate(corrector, predicate)
           range = predicate.loc.dot.with(
-            end_pos: predicate.loc.expression.end_pos
+            end_pos: predicate.source_range.end_pos
           )
 
           corrector.remove(range)
 
-          block_range = block_loc(predicate)
+          block_range = LocationHelp.block_with_whitespace(predicate)
           corrector.remove(block_range) if block_range
         end
 
         def rewrite_matcher(corrector, predicate, matcher)
-          args = args_loc(predicate).source
-          block_loc = block_loc(predicate)
+          args = LocationHelp.arguments_with_whitespace(predicate).source
+          block_loc = LocationHelp.block_with_whitespace(predicate)
           block = block_loc ? block_loc.source : ''
 
           corrector.replace(
-            matcher.loc.expression,
+            matcher.source_range,
             to_predicate_matcher(predicate.method_name) + args + block
           )
         end
@@ -214,19 +214,19 @@ module RuboCop
 
         def corrector_explicit(corrector, to_node, actual, matcher, block_child)
           replacement_matcher = replacement_matcher(to_node)
-          corrector.replace(matcher.loc.expression, replacement_matcher)
+          corrector.replace(matcher.source_range, 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)
           predicate = to_predicate_method(matcher.method_name)
-          args = args_loc(matcher).source
-          block_loc = block_loc(block_child)
+          args = LocationHelp.arguments_with_whitespace(matcher).source
+          block_loc = LocationHelp.block_with_whitespace(block_child)
           block = block_loc ? block_loc.source : ''
 
           corrector.remove(block_loc) if block_loc
-          corrector.insert_after(actual.loc.expression,
+          corrector.insert_after(actual.source_range,
                                  ".#{predicate}" + args + block)
         end
 
@@ -332,31 +332,6 @@ module RuboCop
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           check_explicit(node) if style == :explicit
         end
-
-        private
-
-        # returns args location with whitespace
-        # @example
-        #   foo 1, 2
-        #      ^^^^^
-        def args_loc(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
-
-        # returns block location with whitespace
-        # @example
-        #   foo { bar }
-        #      ^^^^^^^^
-        def block_loc(send_node)
-          parent = send_node.parent
-          return unless parent.block_type?
-
-          send_node.loc.expression.end.with(
-            end_pos: parent.loc.expression.end_pos
-          )
-        end
       end
     end
   end

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

@@ -96,12 +96,12 @@ module RuboCop
           # @return [Parser::Source::Range]
           def remove_range(node)
             if node.left_sibling
-              node.loc.expression.with(
-                begin_pos: node.left_sibling.loc.expression.end_pos
+              node.source_range.with(
+                begin_pos: node.left_sibling.source_range.end_pos
               )
             elsif node.right_sibling
-              node.loc.expression.with(
-                end_pos: node.right_sibling.loc.expression.begin_pos
+              node.source_range.with(
+                end_pos: node.right_sibling.source_range.begin_pos
               )
             end
           end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module Rails
+        # Prefer to travel in `before` rather than `around`.
+        #
+        # @safety
+        #   This cop is unsafe because the automatic `travel_back` is only run
+        #   on test cases that are considered as Rails related.
+        #
+        #   And also, this cop's autocorrection is unsafe because the order of
+        #   execution will change if other steps exist before traveling in
+        #   `around`.
+        #
+        # @example
+        #   # bad
+        #   around do |example|
+        #     freeze_time do
+        #       example.run
+        #     end
+        #   end
+        #
+        #   # good
+        #   before { freeze_time }
+        class TravelAround < Base
+          extend AutoCorrector
+
+          MSG = 'Prefer to travel in `before` rather than `around`.'
+
+          TRAVEL_METHOD_NAMES = %i[
+            freeze_time
+            travel
+            travel_to
+          ].to_set.freeze
+
+          # @!method extract_run_in_travel(node)
+          def_node_matcher :extract_run_in_travel, <<~PATTERN
+            (block
+              $(send nil? TRAVEL_METHOD_NAMES ...)
+              (args ...)
+              (send _ :run)
+            )
+          PATTERN
+
+          # @!method match_around_each?(node)
+          def_node_matcher :match_around_each?, <<~PATTERN
+            (block
+              (send _ :around (sym :each)?)
+              ...
+            )
+          PATTERN
+
+          def on_block(node)
+            run_node = extract_run_in_travel(node)
+            return unless run_node
+
+            around_node = extract_surrounding_around_block(run_node)
+            return unless around_node
+
+            add_offense(node) do |corrector|
+              autocorrect(corrector, node, run_node, around_node)
+            end
+          end
+          alias on_numblock on_block
+
+          private
+
+          def autocorrect(corrector, node, run_node, around_node)
+            corrector.replace(
+              node,
+              node.body.source
+            )
+            corrector.insert_before(
+              around_node,
+              "before { #{run_node.source} }\n\n"
+            )
+          end
+
+          # @param node [RuboCop::AST::BlockNode]
+          # @return [RuboCop::AST::BlockNode, nil]
+          def extract_surrounding_around_block(node)
+            node.each_ancestor(:block).find do |ancestor|
+              match_around_each?(ancestor)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -80,7 +80,7 @@ module RuboCop
 
         def range(node, offending_node)
           offending_node.loc.dot.with(
-            end_pos: node.loc.expression.end_pos
+            end_pos: node.source_range.end_pos
           )
         end
       end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Remove redundant `around` hook.
+      #
+      # @example
+      #   # bad
+      #   around do |example|
+      #     example.run
+      #   end
+      #
+      #   # good
+      #
+      class RedundantAround < Base
+        extend AutoCorrector
+
+        MSG = 'Remove redundant `around` hook.'
+
+        RESTRICT_ON_SEND = %i[around].freeze
+
+        def on_block(node)
+          return unless match_redundant_around_hook_block?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+        alias on_numblock on_block
+
+        def on_send(node)
+          return unless match_redundant_around_hook_send?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        # @!method match_redundant_around_hook_block?(node)
+        def_node_matcher :match_redundant_around_hook_block?, <<~PATTERN
+          (block
+            (send _ :around ...)
+            (args _?)
+            (send _ :run)
+          )
+        PATTERN
+
+        # @!method match_redundant_around_hook_send?(node)
+        def_node_matcher :match_redundant_around_hook_send?, <<~PATTERN
+          (send
+            _
+            :around
+            ...
+            (block-pass
+              (sym :run)
+            )
+          )
+        PATTERN
+
+        def autocorrect(corrector, node)
+          corrector.remove(node)
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,8 @@ module RuboCop
       #   end
       #
       class RepeatedExampleGroupBody < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
@@ -59,11 +61,6 @@ module RuboCop
         # @!method const_arg(node)
         def_node_matcher :const_arg, '(block (send _ _ $const ...) ...)'
 
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending} ...) ...>)
-        PATTERN
-
         def on_begin(node)
           return unless several_example_groups?(node)
 
@@ -78,7 +75,7 @@ module RuboCop
           node
             .children
             .select { |child| example_group_with_body?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .group_by { |group| signature_keys(group) }
             .values
             .reject(&:one?)

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

@@ -43,6 +43,8 @@ module RuboCop
       #   end
       #
       class RepeatedExampleGroupDescription < Base
+        include SkipOrPending
+
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
@@ -55,11 +57,6 @@ module RuboCop
           (block (send _ _ $_ $...) ...)
         PATTERN
 
-        # @!method skip_or_pending?(node)
-        def_node_matcher :skip_or_pending?, <<-PATTERN
-          (block <(send nil? {:skip :pending}) ...>)
-        PATTERN
-
         # @!method empty_description?(node)
         def_node_matcher :empty_description?, '(block (send _ _) ...)'
 
@@ -77,7 +74,7 @@ module RuboCop
           node
             .children
             .select { |child| example_group?(child) }
-            .reject { |child| skip_or_pending?(child) }
+            .reject { |child| skip_or_pending_inside_block?(child) }
             .reject { |child| empty_description?(child) }
             .group_by { |group| doc_string_and_metadata(group) }
             .values

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

@@ -56,12 +56,11 @@ module RuboCop
 
         # @!method include_examples?(node)
         def_node_matcher :include_examples?,
-                         send_pattern('#Includes.examples')
+                         '(send nil? #Includes.examples ...)'
 
         # @!method shared_examples_name(node)
-        def_node_matcher :shared_examples_name, <<-PATTERN
-          (send _ #Includes.examples $_ ...)
-        PATTERN
+        def_node_matcher :shared_examples_name,
+                         '(send nil? #Includes.examples $_name ...)'
 
         def on_begin(node)
           return unless several_include_examples?(node)