rubocop-rspec 2.21.0 → 3.0.1

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} ...) ...)
@@ -52,14 +52,23 @@ module RuboCop
 
         # @param text [String]
         def excessive_whitespace?(text)
-          return true if text.start_with?(' ') || text.end_with?(' ')
-
-          text.match?(/[^\n ]  +[^ ]/)
+          text.match?(/
+            # Leading space
+            \A[[:blank:]]
+            |
+            # Trailing space
+            [[:blank:]]\z
+            |
+            # Two or more consecutive spaces, except if they are leading spaces
+            [^[[:space:]]][[:blank:]]{2,}[^[[:blank:]]]
+          /x)
         end
 
         # @param text [String]
         def strip_excessive_whitespace(text)
-          text.strip.gsub(/  +/, ' ')
+          text
+            .gsub(/[[:blank:]]{2,}/, ' ')
+            .gsub(/\A[[:blank:]]|[[:blank:]]\z/, '')
         end
 
         # @param node [RuboCop::AST::Node]

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

@@ -24,7 +24,7 @@ module RuboCop
       class ExpectActual < Base
         extend AutoCorrector
 
-        MSG = 'Provide the actual you are testing to `expect(...)`.'
+        MSG = 'Provide the actual value you are testing to `expect(...)`.'
 
         RESTRICT_ON_SEND = Runners.all
 
@@ -50,34 +50,42 @@ module RuboCop
           regexp
         ].freeze
 
-        SUPPORTED_MATCHERS = %i[eq eql equal be].freeze
+        SKIPPED_MATCHERS = %i[route_to be_routable].freeze
+        CORRECTABLE_MATCHERS = %i[eq eql equal be].freeze
 
         # @!method expect_literal(node)
         def_node_matcher :expect_literal, <<~PATTERN
           (send
             (send nil? :expect $#literal?)
             #Runners.all
-            {
+            ${
               (send (send nil? $:be) :== $_)
               (send nil? $_ $_ ...)
             }
           )
         PATTERN
 
-        def on_send(node)
-          expect_literal(node) do |actual, matcher, expected|
+        def on_send(node) # rubocop:disable Metrics/MethodLength
+          expect_literal(node) do |actual, send_node, matcher, expected|
+            next if SKIPPED_MATCHERS.include?(matcher)
+
             add_offense(actual.source_range) do |corrector|
-              next unless SUPPORTED_MATCHERS.include?(matcher)
+              next unless CORRECTABLE_MATCHERS.include?(matcher)
               next if literal?(expected)
 
-              swap(corrector, actual, expected)
+              corrector.replace(actual, expected.source)
+              if matcher == :be
+                corrector.replace(expected, actual.source)
+              else
+                corrector.replace(send_node, "#{matcher}(#{actual.source})")
+              end
             end
           end
         end
 
         private
 
-        # This is not implement using a NodePattern because it seems
+        # This is not implemented using a NodePattern because it seems
         # to not be able to match against an explicit (nil) sexp
         def literal?(node)
           node && (simple_literal?(node) || complex_literal?(node))
@@ -89,12 +97,7 @@ module RuboCop
 
         def complex_literal?(node)
           COMPLEX_LITERALS.include?(node.type) &&
-            node.each_child_node.all?(&method(:literal?))
-        end
-
-        def swap(corrector, actual, expected)
-          corrector.replace(actual, expected.source)
-          corrector.replace(expected, actual.source)
+            node.each_child_node.all? { |child_node| literal?(child_node) }
         end
       end
     end

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/expect_in_hook.rb

@@ -27,7 +27,7 @@ module RuboCop
         # @!method expectation(node)
         def_node_search :expectation, '(send nil? #Expectations.all ...)'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node)
           return unless hook?(node)
           return if node.body.nil?
 

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Do not use `expect` in let.
+      #
+      # @example
+      #   # bad
+      #   let(:foo) do
+      #     expect(something).to eq 'foo'
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect(something).to eq 'foo'
+      #   end
+      #
+      class ExpectInLet < Base
+        MSG = 'Do not use `%<expect>s` in let'
+
+        # @!method expectation(node)
+        def_node_search :expectation, '(send nil? #Expectations.all ...)'
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          return unless let?(node)
+          return if node.body.nil?
+
+          expectation(node.body) do |expect|
+            add_offense(expect.loc.selector, message: message(expect))
+          end
+        end
+
+        private
+
+        def message(expect)
+          format(MSG, expect: expect.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -22,10 +22,7 @@ module RuboCop
         def on_gvasgn(node)
           return unless inside_example_scope?(node)
 
-          # rubocop:disable InternalAffairs/NodeDestructuring
-          variable_name, _rhs = *node
-          # rubocop:enable InternalAffairs/NodeDestructuring
-          name = variable_name[1..]
+          name = node.name[1..]
           return unless name.eql?('stdout') || name.eql?('stderr')
 
           add_offense(node.loc.name, message: format(MSG, name: name))

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

@@ -34,6 +34,18 @@ module RuboCop
       #   # good
       #   describe 'test' do; end
       #
+      #   # bad
+      #   shared_examples 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_examples 'test' do; end
+      #
+      #   # bad
+      #   shared_context 'test', focus: true do; end
+      #
+      #   # good
+      #   shared_context 'test' do; end
+      #
       #   # bad (does not support autocorrection)
       #   focus 'test' do; end
       #
@@ -44,18 +56,19 @@ 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
             #Examples.regular
             #Examples.skipped
             #Examples.pending
+            #SharedGroups.all
           }
         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
@@ -66,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/indexed_let.rb

@@ -8,6 +8,9 @@ module RuboCop
       # It makes reading the test harder because it's not clear what exactly
       # is tested by this particular example.
       #
+      # The configurable options `AllowedIdentifiers` and `AllowedPatterns`
+      # will also read those set in `Naming/VariableNumber`.
+      #
       # @example `Max: 1 (default)`
       #   # bad
       #   let(:item_1) { create(:item) }
@@ -31,7 +34,20 @@ module RuboCop
       #   let(:item_1) { create(:item) }
       #   let(:item_2) { create(:item) }
       #
+      # @example `AllowedIdentifiers: ['item_1', 'item_2']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
+      # @example `AllowedPatterns: ['item']`
+      #   # good
+      #   let(:item_1) { create(:item) }
+      #   let(:item_2) { create(:item) }
+      #
       class IndexedLet < Base
+        include AllowedIdentifiers
+        include AllowedPattern
+
         MSG = 'This `let` statement uses index in its name. Please give it ' \
               'a meaningful name.'
 
@@ -69,12 +85,27 @@ module RuboCop
         end
 
         def indexed_let?(node)
-          let?(node) && SUFFIX_INDEX_REGEX.match?(let_name(node))
+          let?(node) &&
+            SUFFIX_INDEX_REGEX.match?(let_name(node)) &&
+            !allowed_identifier?(let_name(node).to_s) &&
+            !matches_allowed_pattern?(let_name(node).to_s)
         end
 
         def let_name_stripped_index(node)
           let_name(node).to_s.gsub(INDEX_REGEX, '')
         end
+
+        def cop_config_patterns_values
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedPatterns', [])) +
+            Array(cop_config.fetch('AllowedPatterns', []))
+        end
+
+        def allowed_identifiers
+          Array(config.for_cop('Naming/VariableNumber')
+            .fetch('AllowedIdentifiers', [])) +
+            Array(cop_config.fetch('AllowedIdentifiers', []))
+        end
       end
     end
   end

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

@@ -26,7 +26,7 @@ module RuboCop
       # @example with AssignmentOnly configuration
       #   # rubocop.yml
       #   # RSpec/InstanceVariable:
-      #   #   AssignmentOnly: false
+      #   #   AssignmentOnly: true
       #
       #   # bad
       #   describe MyClass do
@@ -48,16 +48,16 @@ module RuboCop
       class InstanceVariable < Base
         include TopLevelGroup
 
-        MSG = 'Avoid instance variables – use let, ' \
+        MSG = 'Avoid instance variables - use let, ' \
               '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/is_expected_specify.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for `specify` with `is_expected` and one-liner expectations.
+      #
+      # @example
+      #   # bad
+      #   specify { is_expected.to be_truthy }
+      #
+      #   # good
+      #   it { is_expected.to be_truthy }
+      #
+      #   # good
+      #   specify do
+      #     # ...
+      #   end
+      #   specify { expect(sqrt(4)).to eq(2) }
+      #
+      class IsExpectedSpecify < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[specify].freeze
+        IS_EXPECTED_METHODS = ::Set[:is_expected, :are_expected].freeze
+        MSG = 'Use `it` instead of `specify`.'
+
+        # @!method offense?(node)
+        def_node_matcher :offense?, <<~PATTERN
+          (block (send _ :specify) _ (send (send _ IS_EXPECTED_METHODS) ...))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.single_line? && offense?(block_node)
+
+          selector = node.loc.selector
+          add_offense(selector) do |corrector|
+            corrector.replace(selector, 'it')
+          end
+        end
+      end
+    end
+  end
+end

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/leaky_constant_declaration.rb

@@ -17,7 +17,7 @@ module RuboCop
       # Anonymous classes are fine, since they don't result in global
       # namespace name clashes.
       #
-      # @see https://relishapp.com/rspec/rspec-mocks/docs/mutating-constants
+      # @see https://rspec.info/features/3-12/rspec-mocks/mutating-constants
       #
       # @example Constants leak between examples
       #   # bad
@@ -119,7 +119,7 @@ module RuboCop
         private
 
         def inside_describe_block?(node)
-          node.each_ancestor(:block).any?(&method(:spec_group?))
+          node.each_ancestor(:block).any? { |ancestor| spec_group?(ancestor) }
         end
       end
     end

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 ...)
@@ -51,6 +51,10 @@ module RuboCop
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [RSpec::ScatteredLet]
+        end
+
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless example_group_with_body?(node)
 

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

@@ -29,11 +29,10 @@ module RuboCop
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'
 
-        SUPPORTED_STYLES = %w[allow expect].freeze
         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/message_spies.rb

@@ -39,8 +39,6 @@ module RuboCop
                             'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
-        SUPPORTED_STYLES = %w[have_received receive].freeze
-
         RESTRICT_ON_SEND = Runners.all
 
         # @!method message_expectation(node)