rubocop-rspec 2.18.1 → 2.20.0

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

@@ -61,10 +61,9 @@ module RuboCop
         PATTERN
 
         # @!method focused_block?(node)
-        def_node_matcher :focused_block?,
-                         send_pattern(<<~PATTERN)
-                           {#ExampleGroups.focused #Examples.focused}
-                         PATTERN
+        def_node_matcher :focused_block?, <<~PATTERN
+          (send #rspec? {#ExampleGroups.focused #Examples.focused} ...)
+        PATTERN
 
         def on_send(node)
           focus_metadata(node) do |focus|
@@ -88,7 +87,7 @@ module RuboCop
 
         def with_surrounding(focus)
           range_with_space =
-            range_with_surrounding_space(focus.loc.expression, side: :left)
+            range_with_surrounding_space(focus.source_range, side: :left)
 
           range_with_surrounding_comma(range_with_space, :left)
         end

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

@@ -83,8 +83,7 @@ module RuboCop
             style_detected(scope_name)
             msg = explicit_message(scope_name)
             add_offense(method_send, message: msg) do |corrector|
-              scope = implicit_style? ? '' : "(#{style.inspect})"
-              corrector.replace(argument_range(method_send), scope)
+              autocorrect(corrector, node, method_send)
             end
           end
         end
@@ -93,6 +92,13 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, _node, method_send)
+          scope = implicit_style? ? '' : "(#{style.inspect})"
+          corrector.replace(
+            LocationHelp.arguments_with_whitespace(method_send), scope
+          )
+        end
+
         def check_implicit(method_send)
           style_detected(:implicit)
           return if implicit_style?
@@ -100,7 +106,10 @@ module RuboCop
           msg = explicit_message(nil)
           add_offense(method_send.loc.selector, message: msg) do |corrector|
             scope = "(#{style.inspect})"
-            corrector.replace(argument_range(method_send), scope)
+            corrector.replace(
+              LocationHelp.arguments_with_whitespace(method_send),
+              scope
+            )
           end
         end
 
@@ -119,12 +128,6 @@ module RuboCop
         def hook(node, &block)
           scoped_hook(node, &block) || unscoped_hook(node, &block)
         end
-
-        def argument_range(send_node)
-          send_node.loc.selector.end.with(
-            end_pos: send_node.loc.expression.end_pos
-          )
-        end
       end
     end
   end

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

@@ -30,9 +30,11 @@ module RuboCop
         # @!method example_or_group?(node)
         def_node_matcher :example_or_group?, <<-PATTERN
           {
-            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
-            #{numblock_pattern('{#ExampleGroups.all #Examples.all}')}
-            #{send_pattern('#Includes.examples')}
+            ({block numblock} {
+              (send #rspec? #ExampleGroups.all ...)
+              (send nil? #Examples.all ...)
+            } ...)
+            (send nil? #Includes.examples ...)
           }
         PATTERN
 

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not set up test data using indexes (e.g., `item_1`, `item_2`).
+      #
+      # It makes reading the test harder because it's not clear what exactly
+      # is tested by this particular example.
+      #
+      # @example `Max: 1 (default)`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      #   let(:item1) { create(:item) }
+      #   let(:item2) { create(:item) }
+      #
+      #   # good
+      #
+      #   let(:visible_item) { create(:item, visible: true) }
+      #   let(:invisible_item) { create(:item, visible: false) }
+      #
+      # @example `Max: 2`
+      #   # bad
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #   let(:item_3) { create(:item) }
+      #
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      class IndexedLet < Base
+        MSG = 'This `let` statement uses index in its name. Please give it ' \
+              'a meaningful name.'
+
+        # @!method let_name(node)
+        def_node_matcher :let_name, <<~PATTERN
+          {
+            (block (send nil? #Helpers.all ({str sym} $_) ...) ...)
+            (send nil? #Helpers.all ({str sym} $_) block_pass)
+          }
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless spec_group?(node)
+
+          children = node.body&.child_nodes
+          return unless children
+
+          filter_indexed_lets(children).each do |let_node|
+            add_offense(let_node)
+          end
+        end
+
+        private
+
+        INDEX_REGEX = /_?\d+/.freeze
+
+        def filter_indexed_lets(candidates)
+          candidates
+            .filter { |node| indexed_let?(node) }
+            .group_by { |node| let_name(node).to_s.gsub(INDEX_REGEX, '') }
+            .values
+            .filter { |lets| lets.length > cop_config['Max'] }
+            .flatten
+        end
+
+        def indexed_let?(node)
+          let?(node) && INDEX_REGEX.match?(let_name(node))
+        end
+      end
+    end
+  end
+end

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

@@ -38,16 +38,16 @@ module RuboCop
         # @!method example_or_group?(node)
         def_node_matcher :example_or_group?, <<-PATTERN
           {
-            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
-            #{send_pattern('#Includes.examples')}
+            (block (send nil? {#ExampleGroups.all #Examples.all} ...) ...)
+            (send nil? #Includes.examples ...)
           }
         PATTERN
 
         # @!method include_examples?(node)
         def_node_matcher :include_examples?, <<~PATTERN
           {
-            #{block_pattern(':include_examples')}
-            #{send_pattern(':include_examples')}
+            (block (send nil? :include_examples ...) ...)
+            (send nil? :include_examples ...)
           }
         PATTERN
 

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

@@ -29,14 +29,12 @@ module RuboCop
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
         # @!method example_or_shared_group_or_including?(node)
-        def_node_matcher :example_or_shared_group_or_including?,
-                         block_pattern(<<~PATTERN)
-                           {
-                             #SharedGroups.all
-                             #ExampleGroups.all
-                             #Includes.all
-                           }
-                         PATTERN
+        def_node_matcher :example_or_shared_group_or_including?, <<~PATTERN
+          (block {
+            (send #rspec? {#SharedGroups.all #ExampleGroups.all} ...)
+            (send nil? #Includes.all ...)
+          } ...)
+        PATTERN
 
         # @!method let_bang(node)
         def_node_matcher :let_bang, <<-PATTERN

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks where `match_array` is used.
+      #
+      # This cop checks for the following:
+      # - Prefer `contain_exactly` when matching an array with values.
+      # - Prefer `eq` when using `match_array` with an empty array literal.
+      #
+      # @example
+      #   # bad
+      #   it { is_expected.to match_array([content1, content2]) }
+      #
+      #   # good
+      #   it { is_expected.to contain_exactly(content1, content2) }
+      #
+      #   # good
+      #   it { is_expected.to match_array([content] + array) }
+      #
+      #   # good
+      #   it { is_expected.to match_array(%w(tremble in fear foolish mortals)) }
+      #
+      class MatchArray < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `contain_exactly` when matching an array literal.'
+        RESTRICT_ON_SEND = %i[match_array].freeze
+
+        # @!method match_array_with_empty_array?(node)
+        def_node_matcher :match_array_with_empty_array?, <<~PATTERN
+          (send nil? :match_array (array))
+        PATTERN
+
+        def on_send(node)
+          return unless node.first_argument.array_type?
+          return if match_array_with_empty_array?(node)
+
+          check_populated_array(node)
+        end
+
+        private
+
+        def check_populated_array(node)
+          return if node.first_argument.percent_literal?
+
+          add_offense(node) do |corrector|
+            array_contents = node.arguments.flat_map(&:to_a)
+            corrector.replace(
+              node,
+              "contain_exactly(#{array_contents.map(&:source).join(', ')})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,8 +25,7 @@ module RuboCop
 
         def missing_separating_line(node)
           line = final_end_line = final_end_location(node).line
-
-          while comment_line?(processed_source[line])
+          while processed_source.line_with_comment?(line + 1)
             line += 1
             comment = processed_source.comment_at_line(line)
             if DirectiveComment.new(comment).enabled?

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,99 @@ 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 skipped_by_example_method_with_block?(node)
+        def_node_matcher :skipped_by_example_method_with_block?, <<~PATTERN
+          ({block numblock} (send nil? ${#Examples.skipped #Examples.pending} ...) ...)
+        PATTERN
+
+        # @!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)
           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)
+          skipped_in_example?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+        end
+
+        def on_pending_by_metadata(node)
+          metadata_without_reason?(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_skipped_by_example_method(node)
+          skipped_by_example_method?(node) do |pending|
+            add_offense(node, message: "Give the reason for #{pending}.")
+          end
+
+          skipped_by_example_method_with_block?(node.parent) 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,
             to_predicate_matcher(predicate.method_name) + args + block
           )
         end
@@ -214,20 +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, 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,
-                                 ".#{predicate}" + args + block)
+          corrector.insert_after(actual, ".#{predicate}" + args + block)
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -332,31 +331,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