rubocop-rspec 2.21.0 → 3.0.1

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

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use consistent metadata style.
+      #
+      # This cop does not support autocorrection in the case of
+      # `EnforcedStyle: hash` where the trailing metadata type is ambiguous.
+      # (e.g. `describe 'Something', :a, b`)
+      #
+      # @example EnforcedStyle: symbol (default)
+      #   # bad
+      #   describe 'Something', a: true
+      #
+      #   # good
+      #   describe 'Something', :a
+      #
+      # @example EnforcedStyle: hash
+      #   # bad
+      #   describe 'Something', :a
+      #
+      #   # good
+      #   describe 'Something', a: true
+      class MetadataStyle < Base # rubocop:disable Metrics/ClassLength
+        extend AutoCorrector
+
+        include ConfigurableEnforcedStyle
+        include Metadata
+        include RangeHelp
+
+        # @!method extract_metadata_hash(node)
+        def_node_matcher :extract_metadata_hash, <<~PATTERN
+          (send _ _ _ ... $hash)
+        PATTERN
+
+        # @!method match_boolean_metadata_pair?(node)
+        def_node_matcher :match_boolean_metadata_pair?, <<~PATTERN
+          (pair sym true)
+        PATTERN
+
+        # @!method match_ambiguous_trailing_metadata?(node)
+        def_node_matcher :match_ambiguous_trailing_metadata?, <<~PATTERN
+          (send _ _ _ ... !{hash sym})
+        PATTERN
+
+        def on_metadata(symbols, hash)
+          # RSpec example groups accept two string arguments. In such a case,
+          # the rspec_metadata matcher will interpret the second string
+          # argument as a metadata symbol.
+          symbols.shift if symbols.first&.str_type?
+
+          symbols.each do |symbol|
+            on_metadata_symbol(symbol)
+          end
+
+          return unless hash
+
+          hash.pairs.each do |pair|
+            on_metadata_pair(pair)
+          end
+        end
+
+        private
+
+        def autocorrect_pair(corrector, node)
+          remove_pair(corrector, node)
+          insert_symbol(corrector, node)
+        end
+
+        def autocorrect_symbol(corrector, node)
+          return if match_ambiguous_trailing_metadata?(node.parent)
+
+          remove_symbol(corrector, node)
+          insert_pair(corrector, node)
+        end
+
+        def bad_metadata_pair?(node)
+          style == :symbol && match_boolean_metadata_pair?(node)
+        end
+
+        def bad_metadata_symbol?(_node)
+          style == :hash
+        end
+
+        def format_symbol_to_pair_source(node)
+          "#{node.value}: true"
+        end
+
+        def insert_pair(corrector, node)
+          hash_node = extract_metadata_hash(node.parent)
+          if hash_node.nil?
+            insert_pair_as_last_argument(corrector, node)
+          elsif hash_node.pairs.any?
+            insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          else
+            insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          end
+        end
+
+        def insert_pair_as_last_argument(corrector, node)
+          corrector.insert_before(
+            node.parent.location.end || node.parent.source_range.with(
+              begin_pos: node.parent.source_range.end_pos
+            ),
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_pair_to_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.location.begin,
+            " #{format_symbol_to_pair_source(node)} "
+          )
+        end
+
+        def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node)
+          corrector.insert_after(
+            hash_node.children.last,
+            ", #{format_symbol_to_pair_source(node)}"
+          )
+        end
+
+        def insert_symbol(corrector, node)
+          corrector.insert_after(
+            node.parent.left_sibling,
+            ", #{node.key.value.inspect}"
+          )
+        end
+
+        def message_for_style
+          format(
+            'Use %<style>s style for metadata.',
+            style: style
+          )
+        end
+
+        def on_metadata_pair(node)
+          return unless bad_metadata_pair?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_pair(corrector, node)
+          end
+        end
+
+        def on_metadata_symbol(node)
+          return unless bad_metadata_symbol?(node)
+
+          add_offense(node, message: message_for_style) do |corrector|
+            autocorrect_symbol(corrector, node)
+          end
+        end
+
+        def remove_pair(corrector, node)
+          if !node.parent.braces? || node.left_siblings.any?
+            remove_pair_following(corrector, node)
+          elsif node.right_siblings.any?
+            remove_pair_preceding(corrector, node)
+          else
+            corrector.remove(node)
+          end
+        end
+
+        def remove_pair_following(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+
+        def remove_pair_preceding(corrector, node)
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+        end
+
+        def remove_symbol(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if `.to`, `not_to` or `to_not` are used.
+      #
+      # The RSpec::Expectations::ExpectationTarget must use `to`, `not_to` or
+      # `to_not` to run. Therefore, this cop checks if other methods are used.
+      #
+      # @example
+      #   # bad
+      #   expect(something).kind_of? Foo
+      #   is_expected == 42
+      #   expect{something}.eq? BarError
+      #
+      #   # good
+      #   expect(something).to be_a Foo
+      #   is_expected.to eq 42
+      #   expect{something}.to raise_error BarError
+      #
+      class MissingExpectationTargetMethod < Base
+        MSG = 'Use `.to`, `.not_to` or `.to_not` to set an expectation.'
+        RESTRICT_ON_SEND = %i[expect is_expected].freeze
+
+        # @!method expect?(node)
+        def_node_matcher :expect?, <<~PATTERN
+          {
+            (send nil? :expect ...)
+            (send nil? :is_expected)
+          }
+        PATTERN
+
+        # @!method expect_block?(node)
+        def_node_matcher :expect_block?, <<~PATTERN
+          (block #expect? (args) _body)
+        PATTERN
+
+        # @!method expectation_without_runner?(node)
+        def_node_matcher :expectation_without_runner?, <<~PATTERN
+          (send {#expect? #expect_block?} !#Runners.all ...)
+        PATTERN
+
+        def on_send(node)
+          node = node.parent if node.parent&.block_type?
+
+          expectation_without_runner?(node.parent) do
+            add_offense(node.parent.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for file.
+      module FileHelp
+        def expanded_file_path
+          File.expand_path(processed_source.file_path)
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RuboCop
         def_node_matcher :rspec_metadata, <<~PATTERN
           (block
             (send
-              #rspec? {#Examples.all #ExampleGroups.all #SharedGroups.all #Hooks.all} _ ${send str sym}* (hash $...)?)
+              #rspec? {#Examples.all #ExampleGroups.all #SharedGroups.all #Hooks.all} _ $...)
             ...)
         PATTERN
 
@@ -24,25 +24,39 @@ module RuboCop
 
         # @!method metadata_in_block(node)
         def_node_search :metadata_in_block, <<~PATTERN
-          (send (lvar %) #Hooks.all _ ${send str sym}* (hash $...)?)
+          (send (lvar %) #Hooks.all _ $...)
         PATTERN
 
         def on_block(node)
           rspec_configure(node) do |block_var|
-            metadata_in_block(node, block_var) do |symbols, pairs|
-              on_metadata(symbols, pairs.flatten)
+            metadata_in_block(node, block_var) do |metadata_arguments|
+              on_metadata_arguments(metadata_arguments)
             end
           end
 
-          rspec_metadata(node) do |symbols, pairs|
-            on_metadata(symbols, pairs.flatten)
+          rspec_metadata(node) do |metadata_arguments|
+            on_metadata_arguments(metadata_arguments)
           end
         end
         alias on_numblock on_block
 
-        def on_metadata(_symbols, _pairs)
+        def on_metadata(_symbols, _hash)
           raise ::NotImplementedError
         end
+
+        private
+
+        def on_metadata_arguments(metadata_arguments)
+          *symbols, last = metadata_arguments
+          hash = nil
+          case last&.type
+          when :hash
+            hash = last
+          when :sym
+            symbols << last
+          end
+          on_metadata(symbols, hash)
+        end
       end
     end
   end

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

@@ -8,7 +8,7 @@ module RuboCop
         extend RuboCop::NodePattern::Macros
 
         # @!method skipped_in_metadata?(node)
-        def_node_matcher :skipped_in_metadata?, <<-PATTERN
+        def_node_matcher :skipped_in_metadata?, <<~PATTERN
           {
             (send _ _ <(sym {:skip :pending}) ...>)
             (send _ _ ... (hash <(pair (sym {:skip :pending}) { true str dstr }) ...>))
@@ -30,7 +30,7 @@ module RuboCop
         #
         #   @param node [RuboCop::AST::Node]
         #   @return [Array<RuboCop::AST::Node>] matching nodes
-        def_node_matcher :skip_or_pending_inside_block?, <<-PATTERN
+        def_node_matcher :skip_or_pending_inside_block?, <<~PATTERN
           (block <(send nil? {:skip :pending} ...) ...>)
         PATTERN
       end

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

@@ -30,7 +30,7 @@ module RuboCop
 
         def on_top_level_group(node)
           top_level_example_groups =
-            top_level_groups.select(&method(:example_group?))
+            top_level_groups.select { |group| example_group?(group) }
 
           return if top_level_example_groups.one?
           return unless top_level_example_groups.first.equal?(node)

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

@@ -31,7 +31,7 @@ module RuboCop
       #   end
       #
       # @example `aggregate_failures: true` (default)
-      #  # good - the cop ignores when RSpec aggregates failures
+      #   # good - the cop ignores when RSpec aggregates failures
       #   describe UserCreator do
       #     it 'builds a user', :aggregate_failures do
       #       expect(user.name).to eq("John")
@@ -40,7 +40,7 @@ module RuboCop
       #   end
       #
       # @example `aggregate_failures: false`
-      #  # Detected as an offense
+      #   # Detected as an offense
       #   describe UserCreator do
       #     it 'builds a user', aggregate_failures: false do
       #       expect(user.name).to eq("John")
@@ -48,12 +48,17 @@ module RuboCop
       #     end
       #   end
       #
-      # @example configuration
-      #   # .rubocop.yml
-      #   # RSpec/MultipleExpectations:
-      #   #   Max: 2
+      # @example `Max: 1` (default)
+      #   # bad
+      #   describe UserCreator do
+      #     it 'builds a user' do
+      #       expect(user.name).to eq("John")
+      #       expect(user.age).to eq(22)
+      #     end
+      #   end
       #
-      #   # not flagged by rubocop
+      # @example `Max: 2`
+      #   # good
       #   describe UserCreator do
       #     it 'builds a user' do
       #       expect(user.name).to eq("John")
@@ -67,10 +72,10 @@ module RuboCop
         MSG = 'Example has too many expectations [%<total>d/%<max>d].'
 
         ANYTHING = ->(_node) { true }
-        TRUE = ->(node) { node.true_type? }
+        TRUE_NODE = lambda(&:true_type?)
 
         # @!method aggregate_failures?(node)
-        def_node_matcher :aggregate_failures?, <<-PATTERN
+        def_node_matcher :aggregate_failures?, <<~PATTERN
           (block {
               (send _ _ <(sym :aggregate_failures) ...>)
               (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
@@ -81,7 +86,7 @@ module RuboCop
         def_node_matcher :expect?, '(send nil? #Expectations.all ...)'
 
         # @!method aggregate_failures_block?(node)
-        def_node_matcher :aggregate_failures_block?, <<-PATTERN
+        def_node_matcher :aggregate_failures_block?, <<~PATTERN
           (block (send nil? :aggregate_failures ...) ...)
         PATTERN
 
@@ -105,7 +110,7 @@ module RuboCop
           node_with_aggregate_failures = find_aggregate_failures(example_node)
           return false unless node_with_aggregate_failures
 
-          aggregate_failures?(node_with_aggregate_failures, TRUE)
+          aggregate_failures?(node_with_aggregate_failures, TRUE_NODE)
         end
 
         def find_aggregate_failures(example_node)

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

@@ -108,10 +108,8 @@ module RuboCop
         attr_reader :example_group_memoized_helpers
 
         def all_helpers(node)
-          [
-            *helpers(node),
-            *node.each_ancestor(:block).flat_map(&method(:helpers))
-          ]
+          helpers(node) +
+            node.each_ancestor(:block).flat_map { |ancestor| helpers(ancestor) }
         end
 
         def helpers(node)

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

@@ -107,8 +107,11 @@ module RuboCop
         private
 
         def ignored_shared_example?(node)
-          cop_config['IgnoreSharedExamples'] &&
-            node.each_ancestor(:block).any?(&method(:shared_example?))
+          return false unless cop_config['IgnoreSharedExamples']
+
+          node.each_ancestor(:block).any? do |ancestor|
+            shared_example?(ancestor)
+          end
         end
 
         def check_explicit_subject(node)
@@ -145,7 +148,7 @@ module RuboCop
         end
 
         def find_subject(block_node)
-          block_node.body.child_nodes.find { |send_node| subject?(send_node) }
+          block_node.body&.child_nodes&.find { |send_node| subject?(send_node) }
         end
       end
     end

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

@@ -41,10 +41,15 @@ module RuboCop
         def_node_matcher :skippable?, <<~PATTERN
           {
             (send #rspec? #ExampleGroups.regular ...)
-            (send nil? #Examples.regular ...)
+            #skippable_example?
           }
         PATTERN
 
+        # @!method skippable_example?(node)
+        def_node_matcher :skippable_example?, <<~PATTERN
+          (send nil? #Examples.regular ...)
+        PATTERN
+
         # @!method pending_block?(node)
         def_node_matcher :pending_block?, <<~PATTERN
           {
@@ -62,7 +67,12 @@ module RuboCop
         private
 
         def skipped?(node)
-          skippable?(node) && skipped_in_metadata?(node)
+          (skippable?(node) && skipped_in_metadata?(node)) ||
+            skipped_regular_example_without_body?(node)
+        end
+
+        def skipped_regular_example_without_body?(node)
+          skippable_example?(node) && !node.block_node
         end
       end
     end

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

@@ -103,7 +103,7 @@ module RuboCop
           on_pending_by_metadata(node)
           return unless (parent = parent_node(node))
 
-          if example_group?(parent) || block_node_example_group?(node)
+          if spec_group?(parent) || block_node_example_group?(node)
             on_skipped_by_example_method(node)
             on_skipped_by_example_group_method(node)
           elsif example?(parent)

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

@@ -26,7 +26,7 @@ module RuboCop
         end
 
         # @!method predicate_in_actual?(node)
-        def_node_matcher :predicate_in_actual?, <<-PATTERN
+        def_node_matcher :predicate_in_actual?, <<~PATTERN
           (send
             (send nil? :expect {
               (block $(send !nil? #predicate? ...) ...)
@@ -36,12 +36,12 @@ module RuboCop
         PATTERN
 
         # @!method be_bool?(node)
-        def_node_matcher :be_bool?, <<-PATTERN
+        def_node_matcher :be_bool?, <<~PATTERN
           (send nil? {:be :eq :eql :equal} {true false})
         PATTERN
 
         # @!method be_boolthy?(node)
-        def_node_matcher :be_boolthy?, <<-PATTERN
+        def_node_matcher :be_boolthy?, <<~PATTERN
           (send nil? {:be_truthy :be_falsey :be_falsy :a_truthy_value :a_falsey_value :a_falsy_value})
         PATTERN
 
@@ -74,7 +74,7 @@ module RuboCop
             name[0..-2]
           when 'exist?', 'exists?'
             'exist'
-          when /^has_/
+          when /\Ahas_/
             name.sub('has_', 'have_')[0..-2]
           else
             "be_#{name[0..-2]}"
@@ -174,12 +174,12 @@ module RuboCop
 
         def heredoc_argument?(matcher)
           matcher.arguments.select do |arg|
-            %i[str dstr xstr].include?(arg.type)
+            arg.str_type? || arg.dstr_type? || arg.xstr_type?
           end.any?(&:heredoc?)
         end
 
         # @!method predicate_matcher?(node)
-        def_node_matcher :predicate_matcher?, <<-PATTERN
+        def_node_matcher :predicate_matcher?, <<~PATTERN
           (send
             (send nil? :expect $!nil?)
             #Runners.all
@@ -188,7 +188,7 @@ module RuboCop
         PATTERN
 
         # @!method predicate_matcher_block?(node)
-        def_node_matcher :predicate_matcher_block?, <<-PATTERN
+        def_node_matcher :predicate_matcher_block?, <<~PATTERN
           (block
             (send
               (send nil? :expect $!nil?)
@@ -202,7 +202,7 @@ module RuboCop
 
           return false if allowed_explicit_matchers.include?(name)
 
-          name.start_with?('be_', 'have_') && !name.end_with?('?') ||
+          (name.start_with?('be_', 'have_') && !name.end_with?('?')) ||
             %w[include respond_to].include?(name)
         end
 
@@ -240,10 +240,10 @@ module RuboCop
             'include?'
           when 'respond_to'
             'respond_to?'
-          when /^have_(.+)/
+          when /\Ahave_(.+)/
             "has_#{Regexp.last_match(1)}?"
           else
-            "#{matcher[/^be_(.+)/, 1]}?"
+            "#{matcher[/\Abe_(.+)/, 1]}?"
           end
         end
         # rubocop:enable Metrics/MethodLength

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

@@ -30,7 +30,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[times].freeze
 
         # @!method receive_counts(node)
-        def_node_matcher :receive_counts, <<-PATTERN
+        def_node_matcher :receive_counts, <<~PATTERN
           (send $(send _ {:exactly :at_least :at_most} (int {1 2})) :times)
         PATTERN