rubocop-rspec 1.39.0 → 1.43.1

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   describe "A feature example" do
       #   end
-      class MissingExampleGroupArgument < Cop
+      class MissingExampleGroupArgument < Base
         MSG = 'The first argument to `%<method>s` should not be empty.'
 
         def on_block(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module RSpec
-      # Checks for multiple top level describes.
+      # Checks for multiple top-level example groups.
       #
       # Multiple descriptions for the same class or module should either
       # be nested or separated into different test files.
@@ -22,17 +22,20 @@ module RuboCop
       #     describe '.do_something_else' do
       #     end
       #   end
-      class MultipleDescribes < Cop
-        include RuboCop::RSpec::TopLevelDescribe
+      class MultipleDescribes < Base
+        include RuboCop::RSpec::TopLevelGroup
 
-        MSG = 'Do not use multiple top level describes - '\
+        MSG = 'Do not use multiple top-level example groups - '\
               'try to nest them.'
 
-        def on_top_level_describe(node, _args)
-          return if single_top_level_describe?
-          return unless top_level_nodes.first.equal?(node)
+        def on_top_level_group(node)
+          top_level_example_groups =
+            top_level_groups.select(&method(:example_group?))
 
-          add_offense(node)
+          return if top_level_example_groups.one?
+          return unless top_level_example_groups.first.equal?(node)
+
+          add_offense(node.send_node)
         end
       end
     end

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

@@ -45,22 +45,18 @@ module RuboCop
       #     end
       #   end
       #
-      class MultipleExpectations < Cop
+      class MultipleExpectations < Base
         include ConfigurableMax
 
         MSG = 'Example has too many expectations [%<total>d/%<max>d].'
 
-        def_node_matcher :aggregate_failures?, <<-PATTERN
-          (block {
-              (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) true) ...>))
-            } ...)
-        PATTERN
+        ANYTHING = ->(_node) { true }
+        TRUE = ->(node) { node.true_type? }
 
-        def_node_matcher :aggregate_failures_present?, <<-PATTERN
+        def_node_matcher :aggregate_failures?, <<-PATTERN
           (block {
               (send _ _ <(sym :aggregate_failures) ...>)
-              (send _ _ ... (hash <(pair (sym :aggregate_failures) _) ...>))
+              (send _ _ ... (hash <(pair (sym :aggregate_failures) %1) ...>))
             } ...)
         PATTERN
 
@@ -89,12 +85,12 @@ module RuboCop
           node_with_aggregate_failures = find_aggregate_failures(example_node)
           return false unless node_with_aggregate_failures
 
-          aggregate_failures?(node_with_aggregate_failures)
+          aggregate_failures?(node_with_aggregate_failures, TRUE)
         end
 
         def find_aggregate_failures(example_node)
           example_node.send_node.each_ancestor(:block)
-            .find { |block_node| aggregate_failures_present?(block_node) }
+            .find { |block_node| aggregate_failures?(block_node, ANYTHING) }
         end
 
         def find_expectation(node, &block)

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks if example groups contain too many `let` and `subject` calls.
+      #
+      # This cop is configurable using the `Max` option and the `AllowSubject`
+      # which will configure the cop to only register offenses on calls to
+      # `let` and not calls to `subject`.
+      #
+      # @example
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #
+      #     context 'when stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      #   # good
+      #   describe MyClass do
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #     let(:quuz) { {} }
+      #   end
+      #
+      #   describe MyClass do
+      #     context 'when stuff' do
+      #       let(:foo) { [] }
+      #       let(:bar) { [] }
+      #       let!(:booger) { [] }
+      #     end
+      #
+      #     context 'when other stuff' do
+      #       let(:qux) { [] }
+      #       let(:quux) { [] }
+      #       let(:quuz) { {} }
+      #     end
+      #   end
+      #
+      # @example when disabling AllowSubject configuration
+      #
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   AllowSubject: false
+      #
+      #   # bad - `subject` counts towards memoized helpers
+      #   describe MyClass do
+      #     subject { {} }
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #     let!(:baz) { [] }
+      #     let(:qux) { [] }
+      #     let(:quux) { [] }
+      #   end
+      #
+      # @example with Max configuration
+      #
+      #   # rubocop.yml
+      #   # RSpec/MultipleMemoizedHelpers:
+      #   #   Max: 1
+      #
+      #   # bad
+      #   describe MyClass do
+      #     let(:foo) { [] }
+      #     let(:bar) { [] }
+      #   end
+      #
+      class MultipleMemoizedHelpers < Base
+        include ConfigurableMax
+        include RuboCop::RSpec::Variable
+
+        MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
+
+        def on_block(node)
+          return unless spec_group?(node)
+
+          count = all_helpers(node).uniq.count
+
+          return if count <= max
+
+          self.max = count
+          add_offense(node, message: format(MSG, count: count, max: max))
+        end
+
+        def on_new_investigation
+          @example_group_memoized_helpers = {}
+        end
+
+        private
+
+        attr_reader :example_group_memoized_helpers
+
+        def all_helpers(node)
+          [
+            *helpers(node),
+            *node.each_ancestor(:block).flat_map(&method(:helpers))
+          ]
+        end
+
+        def helpers(node)
+          @example_group_memoized_helpers[node] ||=
+            variable_nodes(node).map do |variable_node|
+              if variable_node.block_type?
+                variable_definition?(variable_node.send_node)
+              else # block-pass (`let(:foo, &bar)`)
+                variable_definition?(variable_node)
+              end
+            end
+        end
+
+        def variable_nodes(node)
+          example_group = RuboCop::RSpec::ExampleGroup.new(node)
+          if allow_subject?
+            example_group.lets
+          else
+            example_group.lets + example_group.subjects
+          end
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_subject?
+          cop_config['AllowSubject']
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,8 @@ module RuboCop
       #   - If subjects are defined with `subject!` then we don't autocorrect.
       #     This is enough of an edge case that people can just move this to
       #     a `before` hook on their own
-      class MultipleSubjects < Cop
+      class MultipleSubjects < Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = 'Do not set more than one subject per example group'
@@ -44,38 +45,36 @@ module RuboCop
           subjects = RuboCop::RSpec::ExampleGroup.new(node).subjects
 
           subjects[0...-1].each do |subject|
-            add_offense(subject)
+            add_offense(subject) do |corrector|
+              autocorrect(corrector, subject)
+            end
           end
         end
 
-        def autocorrect(node)
-          return unless node.method_name.equal?(:subject) # Ignore `subject!`
+        private
+
+        def autocorrect(corrector, subject)
+          return unless subject.method_name.equal?(:subject) # Ignore `subject!`
 
-          if named_subject?(node)
-            rename_autocorrect(node)
+          if named_subject?(subject)
+            rename_autocorrect(corrector, subject)
           else
-            remove_autocorrect(node)
+            remove_autocorrect(corrector, subject)
           end
         end
 
-        private
-
         def named_subject?(node)
           node.send_node.arguments?
         end
 
-        def rename_autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.send_node.loc.selector, 'let')
-          end
+        def rename_autocorrect(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'let')
         end
 
-        def remove_autocorrect(node)
-          lambda do |corrector|
-            range = range_by_whole_lines(node.source_range,
-                                         include_final_newline: true)
-            corrector.remove(range)
-          end
+        def remove_autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range,
+                                       include_final_newline: true)
+          corrector.remove(range)
         end
       end
     end

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

@@ -41,7 +41,7 @@ module RuboCop
       #
       #     it { is_expected.to be_valid }
       #   end
-      class NamedSubject < Cop
+      class NamedSubject < Base
         MSG = 'Name your test subject if you need '\
               'to reference it explicitly.'
 
@@ -62,7 +62,7 @@ module RuboCop
           return if !rspec_block?(node) || ignored_shared_example?(node)
 
           subject_usage(node) do |subject_node|
-            add_offense(subject_node, location: :selector)
+            add_offense(subject_node.loc.selector)
           end
         end
 

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

@@ -85,9 +85,9 @@ module RuboCop
       #     end
       #   end
       #
-      class NestedGroups < Cop
+      class NestedGroups < Base
         include ConfigurableMax
-        include RuboCop::RSpec::TopLevelDescribe
+        include RuboCop::RSpec::TopLevelGroup
 
         MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
 
@@ -97,13 +97,11 @@ module RuboCop
           "Configuration key `#{DEPRECATED_MAX_KEY}` for #{cop_name} is " \
           'deprecated in favor of `Max`. Please use that instead.'
 
-        def_node_search :find_contexts, ExampleGroups::ALL.block_pattern
-
-        def on_top_level_describe(node, _args)
-          find_nested_contexts(node.parent) do |context, nesting|
+        def on_top_level_group(node)
+          find_nested_example_groups(node) do |example_group, nesting|
             self.max = nesting
             add_offense(
-              context.send_node,
+              example_group.send_node,
               message: message(nesting)
             )
           end
@@ -111,13 +109,14 @@ module RuboCop
 
         private
 
-        def find_nested_contexts(node, nesting: 1, &block)
-          find_contexts(node) do |nested_context|
-            yield(nested_context, nesting) if nesting > max_nesting
+        def find_nested_example_groups(node, nesting: 1, &block)
+          example_group = example_group?(node)
+          yield node, nesting if example_group && nesting > max_nesting
+
+          next_nesting = example_group ? nesting + 1 : nesting
 
-            nested_context.each_child_node do |child|
-              find_nested_contexts(child, nesting: nesting + 1, &block)
-            end
+          node.each_child_node(:block, :begin) do |child|
+            find_nested_example_groups(child, nesting: next_nesting, &block)
           end
         end
 

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

@@ -15,7 +15,8 @@ module RuboCop
       #   it '...' do
       #     expect(false).not_to be_true
       #   end
-      class NotToNot < Cop
+      class NotToNot < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s`.'
@@ -24,14 +25,12 @@ module RuboCop
 
         def on_send(node)
           not_to_not_offense(node, alternative_style) do
-            add_offense(node, location: :selector)
+            add_offense(node.loc.selector) do |corrector|
+              corrector.replace(node.loc.selector, style.to_s)
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, style.to_s) }
-        end
-
         private
 
         def message(_node)

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

@@ -21,7 +21,7 @@ module RuboCop
       #   let(:foo) { bar }
       #   let(:baz) { baz }
       #   let!(:other) { other }
-      class OverwritingSetup < Cop
+      class OverwritingSetup < Base
         MSG = '`%<name>s` is already defined.'
 
         def_node_matcher :setup?, (Helpers::ALL + Subject::ALL).block_pattern

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

@@ -31,7 +31,7 @@ module RuboCop
       #   # good
       #   describe MyClass do
       #   end
-      class Pending < Cop
+      class Pending < Base
         MSG = 'Pending spec found.'
 
         PENDING = Examples::PENDING + Examples::SKIPPED + ExampleGroups::SKIPPED

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

@@ -14,11 +14,14 @@ module RuboCop
         private
 
         def check_inflected(node)
-          predicate_in_actual?(node) do |predicate|
-            add_offense(
-              node,
-              message: message_inflected(predicate)
-            )
+          predicate_in_actual?(node) do |predicate, to, matcher|
+            msg = message_inflected(predicate)
+            add_offense(node, message: msg) do |corrector|
+              remove_predicate(corrector, predicate)
+              corrector.replace(node.loc.selector,
+                                true?(to, matcher) ? 'to' : 'not_to')
+              rewrite_matcher(corrector, predicate, matcher)
+            end
           end
         end
 
@@ -76,17 +79,6 @@ module RuboCop
         end
         # rubocop:enable Metrics/MethodLength
 
-        def autocorrect_inflected(node)
-          predicate_in_actual?(node) do |predicate, to, matcher|
-            lambda do |corrector|
-              remove_predicate(corrector, predicate)
-              corrector.replace(node.loc.selector,
-                                true?(to, matcher) ? 'to' : 'not_to')
-              rewrite_matcher(corrector, predicate, matcher)
-            end
-          end
-        end
-
         def remove_predicate(corrector, predicate)
           range = predicate.loc.dot.with(
             end_pos: predicate.loc.expression.end_pos
@@ -123,7 +115,6 @@ module RuboCop
       end
 
       # A helper for `explicit` style
-      # rubocop:disable Metrics/ModuleLength
       module ExplicitHelper
         include RuboCop::RSpec::Language
         extend NodePattern::Macros
@@ -143,22 +134,21 @@ module RuboCop
         end
 
         def check_explicit(node) # rubocop:disable Metrics/MethodLength
-          predicate_matcher_block?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher_block?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              to_node = node.send_node
+              corrector_explicit(corrector, to_node, actual, matcher, to_node)
+            end
             ignore_node(node.children.first)
             return
           end
 
           return if part_of_ignored_node?(node)
 
-          predicate_matcher?(node) do |_actual, matcher|
-            add_offense(
-              node,
-              message: message_explicit(matcher)
-            )
+          predicate_matcher?(node) do |actual, matcher|
+            add_offense(node, message: message_explicit(matcher)) do |corrector|
+              corrector_explicit(corrector, node, actual, matcher, matcher)
+            end
           end
         end
 
@@ -193,31 +183,11 @@ module RuboCop
                  matcher_name: matcher.method_name)
         end
 
-        def autocorrect_explicit(node)
-          autocorrect_explicit_send(node) ||
-            autocorrect_explicit_block(node)
-        end
-
-        def autocorrect_explicit_send(node)
-          predicate_matcher?(node) do |actual, matcher|
-            corrector_explicit(node, actual, matcher, matcher)
-          end
-        end
-
-        def autocorrect_explicit_block(node)
-          predicate_matcher_block?(node) do |actual, matcher|
-            to_node = node.send_node
-            corrector_explicit(to_node, actual, matcher, to_node)
-          end
-        end
-
-        def corrector_explicit(to_node, actual, matcher, block_child)
-          lambda do |corrector|
-            replacement_matcher = replacement_matcher(to_node)
-            corrector.replace(matcher.loc.expression, replacement_matcher)
-            move_predicate(corrector, actual, matcher, block_child)
-            corrector.replace(to_node.loc.selector, 'to')
-          end
+        def corrector_explicit(corrector, to_node, actual, matcher, block_child)
+          replacement_matcher = replacement_matcher(to_node)
+          corrector.replace(matcher.loc.expression, 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)
@@ -238,18 +208,20 @@ module RuboCop
             'is_a?'
           when 'be_an_instance_of', 'be_instance_of', 'an_instance_of'
             'instance_of?'
-          when 'include', 'respond_to'
-            matcher + '?'
+          when 'include'
+            'include?'
+          when 'respond_to'
+            'respond_to?'
           when /^have_(.+)/
             "has_#{Regexp.last_match(1)}?"
           else
-            matcher[/^be_(.+)/, 1] + '?'
+            "#{matcher[/^be_(.+)/, 1]}?"
           end
         end
         # rubocop:enable Metrics/MethodLength
 
         def replacement_matcher(node)
-          case [cop_config['Strict'], node.method_name == :to]
+          case [cop_config['Strict'], node.method?(:to)]
           when [true, true]
             'be(true)'
           when [true, false]
@@ -261,7 +233,6 @@ module RuboCop
           end
         end
       end
-      # rubocop:enable Metrics/ModuleLength
 
       # Prefer using predicate matcher over using predicate method directly.
       #
@@ -277,12 +248,12 @@ module RuboCop
       #   expect(foo).to be_something
       #
       #   # also good - It checks "true" strictly.
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       # @example Strict: false, EnforcedStyle: inflected
       #   # bad
       #   expect(foo.something?).to be_truthy
-      #   expect(foo).to be(true)
+      #   expect(foo.something?).to be(true)
       #
       #   # good
       #   expect(foo).to be_something
@@ -300,7 +271,8 @@ module RuboCop
       #
       #   # good - the above code is rewritten to it by this cop
       #   expect(foo.something?).to be_truthy
-      class PredicateMatcher < Cop
+      class PredicateMatcher < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
         include InflectedHelper
         include ExplicitHelper
@@ -318,15 +290,6 @@ module RuboCop
           check_explicit(node) if style == :explicit
         end
 
-        def autocorrect(node)
-          case style
-          when :inflected
-            autocorrect_inflected(node)
-          when :explicit
-            autocorrect_explicit(node)
-          end
-        end
-
         private
 
         # returns args location with whitespace