rubocop-rspec 1.43.1 → 2.0.0

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

@@ -22,8 +22,7 @@ module RuboCop
         def_node_matcher :lambda?, <<-PATTERN
           {
             (send (const nil? :Proc) :new)
-            (send nil? :proc)
-            (send nil? :lambda)
+            (send nil? {:proc :lambda})
           }
         PATTERN
 

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :implicit_expect, <<-PATTERN
           {
             (send nil? ${:should :should_not} ...)
-            (send (send nil? $:is_expected) #{Runners::ALL.node_pattern_union} ...)
+            (send (send nil? $:is_expected) #Runners.all ...)
           }
         PATTERN
 

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

@@ -47,7 +47,7 @@ module RuboCop
       #   end
       #
       class InstanceVariable < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Avoid instance variables – use let, ' \
               'a method call, or a local variable (if possible).'

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

@@ -54,13 +54,17 @@ module RuboCop
         private
 
         def offending_node(node)
-          node.parent.each_child_node.find do |sibling|
+          parent(node).each_child_node.find do |sibling|
             break if sibling.equal?(node)
 
             yield sibling if offending?(sibling)
           end
         end
 
+        def parent(node)
+          node.each_ancestor(:block).first.body
+        end
+
         def autocorrect(corrector, node, sibling)
           RuboCop::RSpec::Corrector::MoveNode.new(
             node, corrector, processed_source

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

@@ -37,8 +37,8 @@ module RuboCop
 
         def_node_matcher :example_or_group?, <<-PATTERN
           {
-            #{(Examples::ALL + ExampleGroups::ALL).block_pattern}
-            #{Includes::EXAMPLES.send_pattern}
+            #{block_pattern('{#ExampleGroups.all #Examples.all}')}
+            #{send_pattern('#Includes.examples')}
           }
         PATTERN
 

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

@@ -29,10 +29,13 @@ module RuboCop
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
         def_node_matcher :example_or_shared_group_or_including?,
-                         (
-                           ExampleGroups::ALL + SharedGroups::ALL +
-                           Includes::ALL
-                         ).block_pattern
+                         block_pattern(<<~PATTERN)
+                           {
+                             #SharedGroups.all
+                             #ExampleGroups.all
+                             #Includes.all
+                           }
+                         PATTERN
 
         def_node_matcher :let_bang, <<-PATTERN
           {

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

@@ -36,7 +36,7 @@ module RuboCop
         SUPPORTED_STYLES = %w[have_received receive].freeze
 
         def_node_matcher :message_expectation, %(
-          (send (send nil? :expect $_) #{Runners::ALL.node_pattern_union} ...)
+          (send (send nil? :expect $_) #Runners.all ...)
         )
 
         def_node_search :receive_message, %(

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps determine the offending location if there is not an empty line
+      # following the node. Allows comments to follow directly after.
+      module EmptyLineSeparation
+        include FinalEndLocation
+        include RangeHelp
+
+        def missing_separating_line_offense(node)
+          return if last_child?(node)
+
+          missing_separating_line(node) do |location|
+            msg = yield(node.method_name)
+            add_offense(location, message: msg) do |corrector|
+              corrector.insert_after(location.end, "\n")
+            end
+          end
+        end
+
+        def missing_separating_line(node)
+          line = final_end_location(node).line
+
+          line += 1 while comment_line?(processed_source[line])
+
+          return if processed_source[line].blank?
+
+          yield offending_loc(line)
+        end
+
+        def offending_loc(last_line)
+          offending_line = processed_source[last_line - 1]
+
+          content_length = offending_line.lstrip.length
+          start          = offending_line.length - content_length
+
+          source_range(processed_source.buffer,
+                       last_line, start, content_length)
+        end
+
+        def last_child?(node)
+          return true unless node.parent&.begin_type?
+
+          node.equal?(node.parent.children.last)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps find the true end location of nodes which might contain heredocs.
+      module FinalEndLocation
+        def final_end_location(start_node)
+          heredoc_endings =
+            start_node.each_node(:str, :dstr, :xstr)
+              .select(&:heredoc?)
+              .map { |node| node.loc.heredoc_end }
+
+          [start_node.loc.end, *heredoc_endings].max_by(&:line)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helper methods for top level example group cops
+      module TopLevelGroup
+        extend RuboCop::NodePattern::Macros
+
+        def on_new_investigation
+          super
+
+          top_level_groups.each do |node|
+            on_top_level_example_group(node) if example_group?(node)
+            on_top_level_group(node)
+          end
+        end
+
+        def top_level_groups
+          @top_level_groups ||=
+            top_level_nodes(root_node).select { |n| spec_group?(n) }
+        end
+
+        private
+
+        # Dummy methods to be overridden in the consumer
+        def on_top_level_example_group(_node); end
+
+        def on_top_level_group(_node); end
+
+        def top_level_group?(node)
+          top_level_groups.include?(node)
+        end
+
+        def top_level_nodes(node)
+          return [] if node.nil?
+
+          case node.type
+          when :begin
+            node.children
+          when :module, :class
+            top_level_nodes(node.body)
+          else
+            [node]
+          end
+        end
+
+        def root_node
+          processed_source.ast
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps check offenses with variable definitions
+      module Variable
+        extend RuboCop::NodePattern::Macros
+
+        Subjects = RuboCop::RSpec::Language::Subjects
+        Helpers = RuboCop::RSpec::Language::Helpers
+
+        def_node_matcher :variable_definition?, <<~PATTERN
+          (send nil? {#Subjects.all #Helpers.all}
+            $({sym str dsym dstr} ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module RuboCop
       #     end
       #   end
       class MultipleDescribes < Base
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Do not use multiple top-level example groups - '\
               'try to nest them.'

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

@@ -60,7 +60,7 @@ module RuboCop
             } ...)
         PATTERN
 
-        def_node_matcher :expect?, Expectations::ALL.send_pattern
+        def_node_matcher :expect?, send_pattern('#Expectations.all')
         def_node_matcher :aggregate_failures_block?, <<-PATTERN
           (block (send nil? :aggregate_failures ...) ...)
         PATTERN

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

@@ -85,7 +85,7 @@ module RuboCop
       #
       class MultipleMemoizedHelpers < Base
         include ConfigurableMax
-        include RuboCop::RSpec::Variable
+        include Variable
 
         MSG = 'Example group has too many memoized helpers [%<count>d/%<max>d]'
 
@@ -101,6 +101,7 @@ module RuboCop
         end
 
         def on_new_investigation
+          super
           @example_group_memoized_helpers = {}
         end
 
@@ -128,6 +129,7 @@ module RuboCop
 
         def variable_nodes(node)
           example_group = RuboCop::RSpec::ExampleGroup.new(node)
+
           if allow_subject?
             example_group.lets
           else

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

@@ -42,24 +42,20 @@ module RuboCop
       #     it { is_expected.to be_valid }
       #   end
       class NamedSubject < Base
-        MSG = 'Name your test subject if you need '\
-              'to reference it explicitly.'
+        MSG = 'Name your test subject if you need to reference it explicitly.'
 
-        def_node_matcher :rspec_block?, <<-PATTERN
-          {
-            #{Examples::ALL.block_pattern}
-            #{Hooks::ALL.block_pattern}
-          }
-        PATTERN
+        def_node_matcher :example_or_hook_block?,
+                         block_pattern('{#Examples.all #Hooks.all}')
 
-        def_node_matcher :shared_example?, <<-PATTERN
-          #{SharedGroups::EXAMPLES.block_pattern}
-        PATTERN
+        def_node_matcher :shared_example?,
+                         block_pattern('#SharedGroups.examples')
 
         def_node_search :subject_usage, '$(send nil? :subject)'
 
         def on_block(node)
-          return if !rspec_block?(node) || ignored_shared_example?(node)
+          if !example_or_hook_block?(node) || ignored_shared_example?(node)
+            return
+          end
 
           subject_usage(node) do |subject_node|
             add_offense(subject_node.loc.selector)

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

@@ -87,7 +87,7 @@ module RuboCop
       #
       class NestedGroups < Base
         include ConfigurableMax
-        include RuboCop::RSpec::TopLevelGroup
+        include TopLevelGroup
 
         MSG = 'Maximum example group nesting exceeded [%<total>d/%<max>d].'
 

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

@@ -24,7 +24,8 @@ module RuboCop
       class OverwritingSetup < Base
         MSG = '`%<name>s` is already defined.'
 
-        def_node_matcher :setup?, (Helpers::ALL + Subject::ALL).block_pattern
+        def_node_matcher :setup?, block_pattern('{#Helpers.all #Subjects.all}')
+
         def_node_matcher :first_argument_name, '(send _ _ ({str sym} $_))'
 
         def on_block(node)

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

@@ -34,10 +34,10 @@ module RuboCop
       class Pending < Base
         MSG = 'Pending spec found.'
 
-        PENDING = Examples::PENDING + Examples::SKIPPED + ExampleGroups::SKIPPED
-        SKIPPABLE = ExampleGroups::GROUPS + Examples::EXAMPLES
-
-        def_node_matcher :skippable?, SKIPPABLE.send_pattern
+        def_node_matcher :skippable?,
+                         send_pattern(<<~PATTERN)
+                           {#ExampleGroups.regular #Examples.regular}
+                         PATTERN
 
         def_node_matcher :skipped_in_metadata?, <<-PATTERN
           {
@@ -47,7 +47,15 @@ module RuboCop
         PATTERN
 
         def_node_matcher :skip_or_pending?, '{(sym :skip) (sym :pending)}'
-        def_node_matcher :pending_block?, PENDING.send_pattern
+
+        def_node_matcher :pending_block?,
+                         send_pattern(<<~PATTERN)
+                           {
+                             #ExampleGroups.skipped
+                             #Examples.skipped
+                             #Examples.pending
+                           }
+                         PATTERN
 
         def on_send(node)
           return unless pending_block?(node) || skipped?(node)

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

@@ -30,7 +30,7 @@ module RuboCop
             (send nil? :expect {
               (block $(send !nil? #predicate? ...) ...)
               $(send !nil? #predicate? ...)})
-            $#{Runners::ALL.node_pattern_union}
+            $#Runners.all
             $#boolean_matcher?)
         PATTERN
 
@@ -155,7 +155,7 @@ module RuboCop
         def_node_matcher :predicate_matcher?, <<-PATTERN
           (send
             (send nil? :expect $!nil?)
-            #{Runners::ALL.node_pattern_union}
+            #Runners.all
             {$(send nil? #predicate_matcher_name? ...)
               (block $(send nil? #predicate_matcher_name? ...) ...)})
         PATTERN
@@ -164,7 +164,7 @@ module RuboCop
           (block
             (send
               (send nil? :expect $!nil?)
-              #{Runners::ALL.node_pattern_union}
+              #Runners.all
               $(send nil? #predicate_matcher_name?))
             ...)
         PATTERN

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Check for repeated include of shared examples.
+      #
+      # @example
+      #
+      #    # bad
+      #    describe 'foo' do
+      #      include_examples 'cool stuff'
+      #      include_examples 'cool stuff'
+      #    end
+      #
+      #    # bad
+      #    describe 'foo' do
+      #      it_behaves_like 'a cool', 'thing'
+      #      it_behaves_like 'a cool', 'thing'
+      #    end
+      #
+      #    # bad
+      #    context 'foo' do
+      #      it_should_behave_like 'a duck'
+      #      it_should_behave_like 'a duck'
+      #    end
+      #
+      #    # good
+      #    describe 'foo' do
+      #      include_examples 'cool stuff'
+      #    end
+      #
+      #    describe 'bar' do
+      #      include_examples 'cool stuff'
+      #    end
+      #
+      #    # good
+      #    describe 'foo' do
+      #      it_behaves_like 'a cool', 'thing'
+      #      it_behaves_like 'a cool', 'person'
+      #    end
+      #
+      #    # good
+      #    context 'foo' do
+      #      it_should_behave_like 'a duck'
+      #      it_should_behave_like 'a goose'
+      #    end
+      #
+      class RepeatedIncludeExample < Base
+        MSG = 'Repeated include of shared_examples %<name>s ' \
+          'on line(s) %<repeat>s'
+
+        def_node_matcher :several_include_examples?, <<-PATTERN
+          (begin <#include_examples? #include_examples? ...>)
+        PATTERN
+
+        def_node_matcher :include_examples?,
+                         send_pattern('#Includes.examples')
+
+        def_node_matcher :shared_examples_name, <<-PATTERN
+          (send _ #Includes.examples $_ ...)
+        PATTERN
+
+        def on_begin(node)
+          return unless several_include_examples?(node)
+
+          repeated_include_examples(node).each do |item, repeats|
+            add_offense(item, message: message(item, repeats))
+          end
+        end
+
+        private
+
+        def repeated_include_examples(node)
+          node
+            .children
+            .select { |child| literal_include_examples?(child) }
+            .group_by { |child| signature_keys(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines(items) }
+        end
+
+        def literal_include_examples?(node)
+          include_examples?(node) &&
+            node.arguments.all?(&:recursive_literal_or_const?)
+        end
+
+        def add_repeated_lines(items)
+          repeated_lines = items.map(&:first_line)
+          items.map { |item| [item, repeated_lines - [item.first_line]] }
+        end
+
+        def signature_keys(item)
+          item.arguments
+        end
+
+        def message(item, repeats)
+          format(MSG, name: shared_examples_name(item).source, repeat: repeats)
+        end
+      end
+    end
+  end
+end