rubocop-rspec 2.23.0 → 2.26.1

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Use `eq` instead of `be ==` to compare objects.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be == 42
+      #
+      #   # good
+      #   expect(foo).to eq 42
+      #
+      class Eq < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `eq` instead of `be ==` to compare objects.'
+        RESTRICT_ON_SEND = Runners.all
+
+        # @!method be_equals(node)
+        def_node_matcher :be_equals, <<~PATTERN
+          (send _ #Runners.all $(send (send nil? :be) :== _))
+        PATTERN
+
+        def on_send(node)
+          be_equals(node) do |matcher|
+            range = offense_range(matcher)
+            add_offense(range) do |corrector|
+              corrector.replace(range, 'eq')
+            end
+          end
+        end
+
+        private
+
+        def offense_range(matcher)
+          range_between(
+            matcher.source_range.begin_pos,
+            matcher.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -26,11 +26,12 @@ module RuboCop
       #     expect(result).to be(true)
       #   end
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
-      # will be counted as one line regardless of its actual size.
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'.
+      # Each construct will be counted as one line regardless of
+      # its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   it do
       #     array = [         # +1
@@ -46,7 +47,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
       #
       class ExampleLength < Base
         include CodeLength

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

@@ -22,6 +22,9 @@ module RuboCop
       #   it 'should find nothing' do
       #   end
       #
+      #   it 'will find nothing' do
+      #   end
+      #
       #   # good
       #   it 'finds nothing' do
       #   end
@@ -47,25 +50,30 @@ module RuboCop
         extend AutoCorrector
 
         MSG_SHOULD = 'Do not use should when describing your tests.'
+        MSG_WILL   = 'Do not use the future tense when describing your tests.'
         MSG_IT     = "Do not repeat 'it' when describing your tests."
         MSG_INSUFFICIENT_DESCRIPTION = 'Your example description is ' \
                                        'insufficient.'
 
         SHOULD_PREFIX = /\Ashould(?:n't)?\b/i.freeze
+        WILL_PREFIX   = /\A(?:will|won't)\b/i.freeze
         IT_PREFIX     = /\Ait /i.freeze
 
         # @!method it_description(node)
-        def_node_matcher :it_description, <<-PATTERN
+        def_node_matcher :it_description, <<~PATTERN
           (block (send _ :it ${
             (str $_)
             (dstr (str $_ ) ...)
           } ...) ...)
         PATTERN
 
+        # rubocop:disable Metrics/MethodLength
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           it_description(node) do |description_node, message|
             if message.match?(SHOULD_PREFIX)
               add_wording_offense(description_node, MSG_SHOULD)
+            elsif message.match?(WILL_PREFIX)
+              add_wording_offense(description_node, MSG_WILL)
             elsif message.match?(IT_PREFIX)
               add_wording_offense(description_node, MSG_IT)
             elsif insufficient_docstring?(description_node)
@@ -74,6 +82,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
         private
 
@@ -100,7 +109,7 @@ module RuboCop
         def replacement_text(node)
           text = text(node)
 
-          if text.match?(SHOULD_PREFIX)
+          if text.match?(SHOULD_PREFIX) || text.match?(WILL_PREFIX)
             RuboCop::RSpec::Wording.new(
               text,
               ignore:  ignored_words,

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

@@ -29,7 +29,7 @@ module RuboCop
         MSG = 'Excessive whitespace.'
 
         # @!method example_description(node)
-        def_node_matcher :example_description, <<-PATTERN
+        def_node_matcher :example_description, <<~PATTERN
           (send _ {#Examples.all #ExampleGroups.all} ${
             $str
             $(dstr ({str dstr `sym} ...) ...)
@@ -66,7 +66,9 @@ module RuboCop
 
         # @param text [String]
         def strip_excessive_whitespace(text)
-          text.strip.gsub(/[[:blank:]]{2,}/, ' ')
+          text
+            .gsub(/[[:blank:]]{2,}/, ' ')
+            .gsub(/\A[[:blank:]]|[[:blank:]]\z/, '')
         end
 
         # @param node [RuboCop::AST::Node]

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

@@ -38,12 +38,12 @@ module RuboCop
         RESTRICT_ON_SEND = %i[change].freeze
 
         # @!method expect_change_with_arguments(node)
-        def_node_matcher :expect_change_with_arguments, <<-PATTERN
+        def_node_matcher :expect_change_with_arguments, <<~PATTERN
           (send nil? :change $_ ({sym str} $_))
         PATTERN
 
         # @!method expect_change_with_block(node)
-        def_node_matcher :expect_change_with_block, <<-PATTERN
+        def_node_matcher :expect_change_with_block, <<~PATTERN
           (block
             (send nil? :change)
             (args)

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

@@ -5,6 +5,12 @@ module RuboCop
     module RSpec
       # Checks that spec file paths are consistent and well-formed.
       #
+      # This cop is deprecated.
+      # We plan to remove it in the next major version update to 3.0.
+      # The migration targets are `RSpec/SpecFilePathSuffix`
+      # and `RSpec/SpecFilePathFormat`.
+      # If you are using this cop, please plan for migration.
+      #
       # By default, this checks that spec file paths are consistent with the
       # test subject and enforces that it reflects the described
       # class/module and its optionally called out method.

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

@@ -56,7 +56,7 @@ module RuboCop
         MSG = 'Focused spec found.'
 
         # @!method focusable_selector?(node)
-        def_node_matcher :focusable_selector?, <<-PATTERN
+        def_node_matcher :focusable_selector?, <<~PATTERN
           {
             #ExampleGroups.regular
             #ExampleGroups.skipped
@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         # @!method metadata(node)
-        def_node_matcher :metadata, <<-PATTERN
+        def_node_matcher :metadata, <<~PATTERN
           {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
            (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
@@ -79,6 +79,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if node.chained? || node.each_ancestor(:def, :defs).any?
+
           focus_metadata(node) do |focus|
             add_offense(focus) do |corrector|
               if focus.pair_type? || focus.str_type? || focus.sym_type?

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

@@ -66,12 +66,12 @@ module RuboCop
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
         # @!method scoped_hook(node)
-        def_node_matcher :scoped_hook, <<-PATTERN
+        def_node_matcher :scoped_hook, <<~PATTERN
           ({block numblock} $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
         # @!method unscoped_hook(node)
-        def_node_matcher :unscoped_hook, <<-PATTERN
+        def_node_matcher :unscoped_hook, <<~PATTERN
           ({block numblock} $(send _ #Hooks.all) ...)
         PATTERN
 

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

@@ -28,7 +28,7 @@ module RuboCop
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
         # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
             ({block numblock} {
               (send #rspec? #ExampleGroups.all ...)

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

@@ -22,7 +22,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
 
         # @!method lambda?(node)
-        def_node_matcher :lambda?, <<-PATTERN
+        def_node_matcher :lambda?, <<~PATTERN
           {
             (send (const nil? :Proc) :new)
             (send nil? {:proc :lambda})
@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :lambda_subject?, '(block #lambda? ...)'
 
         # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
+        def_node_matcher :implicit_expect, <<~PATTERN
           $(send nil? {:is_expected :should :should_not} ...)
         PATTERN
 

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

@@ -31,7 +31,7 @@ module RuboCop
         RESTRICT_ON_SEND = Runners.all + %i[should should_not]
 
         # @!method implicit_expect(node)
-        def_node_matcher :implicit_expect, <<-PATTERN
+        def_node_matcher :implicit_expect, <<~PATTERN
           {
             (send nil? ${:should :should_not} ...)
             (send (send nil? $:is_expected) #Runners.all ...)

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

@@ -78,12 +78,12 @@ module RuboCop
         ].freeze
 
         # @!method explicit_unnamed_subject?(node)
-        def_node_matcher :explicit_unnamed_subject?, <<-PATTERN
+        def_node_matcher :explicit_unnamed_subject?, <<~PATTERN
           (send nil? :expect (send nil? :subject))
         PATTERN
 
         # @!method implicit_subject?(node)
-        def_node_matcher :implicit_subject?, <<-PATTERN
+        def_node_matcher :implicit_subject?, <<~PATTERN
           (send nil? {:should :should_not :is_expected} ...)
         PATTERN
 

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

@@ -25,7 +25,7 @@ module RuboCop
               'with `have_received`.'
 
         # @!method null_double(node)
-        def_node_search :null_double, <<-PATTERN
+        def_node_search :null_double, <<~PATTERN
           (lvasgn $_
             (send
               $(send nil? :instance_double
@@ -33,7 +33,7 @@ module RuboCop
         PATTERN
 
         # @!method have_received_usage(node)
-        def_node_search :have_received_usage, <<-PATTERN
+        def_node_search :have_received_usage, <<~PATTERN
           (send
             (send nil? :expect
             (lvar $_)) :to

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

@@ -52,12 +52,12 @@ module RuboCop
               'a method call, or a local variable (if possible).'
 
         # @!method dynamic_class?(node)
-        def_node_matcher :dynamic_class?, <<-PATTERN
+        def_node_matcher :dynamic_class?, <<~PATTERN
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
 
         # @!method custom_matcher?(node)
-        def_node_matcher :custom_matcher?, <<-PATTERN
+        def_node_matcher :custom_matcher?, <<~PATTERN
           (block {
             (send nil? :matcher sym)
             (send (const (const nil? :RSpec) :Matchers) :define sym)

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

@@ -21,7 +21,7 @@ module RuboCop
               'of iterating over an array.'
 
         # @!method each?(node)
-        def_node_matcher :each?, <<-PATTERN
+        def_node_matcher :each?, <<~PATTERN
           (block
             (send ... :each)
             (args (arg $_))
@@ -30,14 +30,14 @@ module RuboCop
         PATTERN
 
         # @!method each_numblock?(node)
-        def_node_matcher :each_numblock?, <<-PATTERN
+        def_node_matcher :each_numblock?, <<~PATTERN
           (numblock
             (send ... :each) _ $(...)
           )
         PATTERN
 
         # @!method expectation?(node)
-        def_node_matcher :expectation?, <<-PATTERN
+        def_node_matcher :expectation?, <<~PATTERN
           (send (send nil? :expect (lvar %)) :to ...)
         PATTERN
 

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

@@ -36,7 +36,7 @@ module RuboCop
         MSG = 'Move `let` before the examples in the group.'
 
         # @!method example_or_group?(node)
-        def_node_matcher :example_or_group?, <<-PATTERN
+        def_node_matcher :example_or_group?, <<~PATTERN
           {
             (block (send nil? {#ExampleGroups.all #Examples.all} ...) ...)
             (send nil? #Includes.examples ...)

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

@@ -37,7 +37,7 @@ module RuboCop
         PATTERN
 
         # @!method let_bang(node)
-        def_node_matcher :let_bang, <<-PATTERN
+        def_node_matcher :let_bang, <<~PATTERN
           {
             (block $(send nil? :let! {(sym $_) (str $_)}) ...)
             $(send nil? :let! {(sym $_) (str $_)} block_pass)

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

@@ -33,7 +33,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[to].freeze
 
         # @!method message_expectation(node)
-        def_node_matcher :message_expectation, <<-PATTERN
+        def_node_matcher :message_expectation, <<~PATTERN
           (send $(send nil? {:expect :allow} ...) :to #receive_message?)
         PATTERN
 

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/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