rubocop-rspec 2.21.0 → 3.0.1

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for multiple messages stubbed on the same object.
+      #
+      # @safety
+      #   The autocorrection is marked as unsafe, because it may change the
+      #   order of stubs. This in turn may cause e.g. variables to be called
+      #   before they are defined.
+      #
+      # @example
+      #   # bad
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:baz).and_return(qux)
+      #   end
+      #
+      #   # good
+      #   before do
+      #     allow(Service).to receive_messages(foo: bar, baz: qux)
+      #   end
+      #
+      #   # good - ignore same message
+      #   before do
+      #     allow(Service).to receive(:foo).and_return(bar)
+      #     allow(Service).to receive(:foo).and_return(qux)
+      #   end
+      #
+      class ReceiveMessages < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `receive_messages` instead of multiple stubs on lines ' \
+              '%<loc>s.'
+
+        # @!method allow_receive_message?(node)
+        def_node_matcher :allow_receive_message?, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym _)) :and_return !#heredoc_or_splat?))
+        PATTERN
+
+        # @!method allow_argument(node)
+        def_node_matcher :allow_argument, <<~PATTERN
+          (send (send nil? :allow $_ ...) ...)
+        PATTERN
+
+        # @!method receive_node(node)
+        def_node_search :receive_node, <<~PATTERN
+          $(send (send nil? :receive ...) ...)
+        PATTERN
+
+        # @!method receive_arg(node)
+        def_node_search :receive_arg, <<~PATTERN
+          (send (send nil? :receive $_) ...)
+        PATTERN
+
+        # @!method receive_and_return_argument(node)
+        def_node_matcher :receive_and_return_argument, <<~PATTERN
+          (send (send nil? :allow ...) :to (send (send nil? :receive (sym $_)) :and_return $_))
+        PATTERN
+
+        def on_begin(node)
+          repeated_receive_message(node).each do |item, repeated_lines, args|
+            next if repeated_lines.empty?
+
+            register_offense(item, repeated_lines, args)
+          end
+        end
+
+        private
+
+        def repeated_receive_message(node)
+          node
+            .children
+            .select { |child| allow_receive_message?(child) }
+            .group_by { |child| allow_argument(child) }
+            .values
+            .reject(&:one?)
+            .flat_map { |items| add_repeated_lines_and_arguments(items) }
+        end
+
+        def add_repeated_lines_and_arguments(items)
+          uniq_items = uniq_items(items)
+          repeated_lines = uniq_items.map(&:first_line)
+          uniq_items.map do |item|
+            [item, repeated_lines - [item.first_line], arguments(uniq_items)]
+          end
+        end
+
+        def uniq_items(items)
+          items.select do |item|
+            items.none? do |i|
+              receive_arg(item).first == receive_arg(i).first &&
+                !same_line?(item, i)
+            end
+          end
+        end
+
+        def arguments(items)
+          items.map do |item|
+            receive_and_return_argument(item) do |receive_arg, return_arg|
+              "#{normalize_receive_arg(receive_arg)}: " \
+                "#{normalize_return_arg(return_arg)}"
+            end
+          end
+        end
+
+        def normalize_receive_arg(receive_arg)
+          if requires_quotes?(receive_arg)
+            "'#{receive_arg}'"
+          else
+            receive_arg
+          end
+        end
+
+        def normalize_return_arg(return_arg)
+          if return_arg.hash_type? && !return_arg.braces?
+            "{ #{return_arg.source} }"
+          else
+            return_arg.source
+          end
+        end
+
+        def register_offense(item, repeated_lines, args)
+          add_offense(item, message: message(repeated_lines)) do |corrector|
+            if item.loc.line > repeated_lines.max
+              replace_to_receive_messages(corrector, item, args)
+            else
+              corrector.remove(item_range_by_whole_lines(item))
+            end
+          end
+        end
+
+        def message(repeated_lines)
+          format(MSG, loc: repeated_lines)
+        end
+
+        def replace_to_receive_messages(corrector, item, args)
+          receive_node(item) do |node|
+            corrector.replace(node,
+                              "receive_messages(#{args.join(', ')})")
+          end
+        end
+
+        def item_range_by_whole_lines(item)
+          range_by_whole_lines(item.source_range, include_final_newline: true)
+        end
+
+        def heredoc_or_splat?(node)
+          ((node.str_type? || node.dstr_type?) && node.heredoc?) ||
+            node.splat_type?
+        end
+
+        def requires_quotes?(value)
+          value.match?(/^:".*?"|=$|^\W+$/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for redundant predicate matcher.
+      #
+      # @example
+      #   # bad
+      #   expect(foo).to be_exist(bar)
+      #   expect(foo).not_to be_include(bar)
+      #   expect(foo).to be_all(bar)
+      #
+      #   # good
+      #   expect(foo).to exist(bar)
+      #   expect(foo).not_to include(bar)
+      #   expect(foo).to all be(bar)
+      #
+      class RedundantPredicateMatcher < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+        RESTRICT_ON_SEND =
+          %i[be_all be_cover be_end_with be_eql be_equal
+             be_exist be_exists be_include be_match
+             be_respond_to be_start_with].freeze
+
+        def on_send(node)
+          return if node.parent.block_type? || node.arguments.empty?
+          return unless replaceable_arguments?(node)
+
+          method_name = node.method_name.to_s
+          replaced = replaced_method_name(method_name)
+          add_offense(node, message: message(method_name,
+                                             replaced)) do |corrector|
+            unless node.method?(:be_all)
+              corrector.replace(node.loc.selector, replaced)
+            end
+          end
+        end
+
+        private
+
+        def message(bad_method, good_method)
+          format(MSG, bad: bad_method, good: good_method)
+        end
+
+        def replaceable_arguments?(node)
+          if node.method?(:be_all)
+            node.first_argument.send_type?
+          else
+            true
+          end
+        end
+
+        def replaced_method_name(method_name)
+          name = method_name.to_s.delete_prefix('be_')
+          if name == 'exists'
+            'exist'
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks that `remove_const` is not used in specs.
+      #
+      # @example
+      #   # bad
+      #   it 'does something' do
+      #     Object.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      #   before do
+      #     SomeClass.send(:remove_const, :SomeConstant)
+      #   end
+      #
+      class RemoveConst < Base
+        include RuboCop::RSpec::Language
+
+        MSG = 'Do not use remove_const in specs. ' \
+              'Consider using e.g. `stub_const`.'
+        RESTRICT_ON_SEND = %i[send __send__].freeze
+
+        # @!method remove_const(node)
+        def_node_matcher :remove_const, <<~PATTERN
+          (send _ {:send | :__send__} (sym :remove_const) _)
+        PATTERN
+
+        # Check for offenses
+        def on_send(node)
+          remove_const(node) do
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,13 @@ module RuboCop
       #
       # @example
       #
-      #    it 'is valid' do
-      #      expect(user).to be_valid
-      #    end
+      #   it 'is valid' do
+      #     expect(user).to be_valid
+      #   end
       #
-      #    it 'validates the user' do
-      #      expect(user).to be_valid
-      #    end
+      #   it 'validates the user' do
+      #     expect(user).to be_valid
+      #   end
       #
       class RepeatedExample < Base
         MSG = "Don't repeat examples within an example group."

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

@@ -48,7 +48,7 @@ module RuboCop
         MSG = 'Repeated %<group>s block body on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group_with_body? #example_group_with_body? ...>)
         PATTERN
 

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

@@ -48,12 +48,12 @@ module RuboCop
         MSG = 'Repeated %<group>s block description on line(s) %<loc>s'
 
         # @!method several_example_groups?(node)
-        def_node_matcher :several_example_groups?, <<-PATTERN
+        def_node_matcher :several_example_groups?, <<~PATTERN
           (begin <#example_group? #example_group? ...>)
         PATTERN
 
         # @!method doc_string_and_metadata(node)
-        def_node_matcher :doc_string_and_metadata, <<-PATTERN
+        def_node_matcher :doc_string_and_metadata, <<~PATTERN
           (block (send _ _ $_ $...) ...)
         PATTERN
 

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

@@ -50,7 +50,7 @@ module RuboCop
               'on line(s) %<repeat>s'
 
         # @!method several_include_examples?(node)
-        def_node_matcher :several_include_examples?, <<-PATTERN
+        def_node_matcher :several_include_examples?, <<~PATTERN
           (begin <#include_examples? #include_examples? ...>)
         PATTERN
 

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for repeated calls to subject missing that it is memoized.
+      #
+      # @example
+      #   # bad
+      #   it do
+      #     subject
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   it do
+      #     expect { subject }.to change { A.count }
+      #     expect { subject }.to not_change { A.count }
+      #   end
+      #
+      #   # good
+      #   it do
+      #     expect { my_method }.to change { A.count }
+      #     expect { my_method }.to not_change { A.count }
+      #   end
+      #
+      #   # also good
+      #   it do
+      #     expect { subject.a }.to change { A.count }
+      #     expect { subject.b }.to not_change { A.count }
+      #   end
+      #
+      class RepeatedSubjectCall < Base
+        include TopLevelGroup
+
+        MSG = 'Calls to subject are memoized, this block is misleading'
+
+        # @!method subject?(node)
+        #   Find a named or unnamed subject definition
+        #
+        #   @example anonymous subject
+        #     subject?(parse('subject { foo }').ast) do |name|
+        #       name # => :subject
+        #     end
+        #
+        #   @example named subject
+        #     subject?(parse('subject(:thing) { foo }').ast) do |name|
+        #       name # => :thing
+        #     end
+        #
+        #   @param node [RuboCop::AST::Node]
+        #
+        #   @yield [Symbol] subject name
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              { #Subjects.all (sym $_) | $#Subjects.all }
+            ) args ...)
+        PATTERN
+
+        # @!method subject_calls(node, method_name)
+        def_node_search :subject_calls, <<~PATTERN
+          (send nil? %)
+        PATTERN
+
+        def on_top_level_group(node)
+          @subjects_by_node = detect_subjects_in_scope(node)
+
+          detect_offenses_in_block(node)
+        end
+
+        private
+
+        def detect_offense(subject_node)
+          return if subject_node.chained?
+          return if subject_node.parent.send_type?
+          return unless (block_node = expect_block(subject_node))
+
+          add_offense(block_node)
+        end
+
+        def expect_block(node)
+          node.each_ancestor(:block).find { |block| block.method?(:expect) }
+        end
+
+        def detect_offenses_in_block(node, subject_names = [])
+          subject_names = [*subject_names, *@subjects_by_node[node]]
+
+          if example?(node)
+            return detect_offenses_in_example(node, subject_names)
+          end
+
+          node.each_child_node(:send, :def, :block, :begin) do |child|
+            detect_offenses_in_block(child, subject_names)
+          end
+        end
+
+        def detect_offenses_in_example(node, subject_names)
+          return unless node.body
+
+          subjects_used = Hash.new(false)
+
+          subject_calls(node.body, Set[*subject_names, :subject]).each do |call|
+            if subjects_used[call.method_name]
+              detect_offense(call)
+            else
+              subjects_used[call.method_name] = true
+            end
+          end
+        end
+
+        def detect_subjects_in_scope(node)
+          node.each_descendant(:block).with_object({}) do |child, h|
+            subject?(child) do |name|
+              outer_example_group = child.each_ancestor(:block).find do |a|
+                example_group?(a)
+              end
+
+              (h[outer_example_group] ||= []) << name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,7 +48,7 @@ module RuboCop
         def_node_matcher :stub_with_block?, '(block #contains_stub? ...)'
 
         # @!method and_return_value(node)
-        def_node_search :and_return_value, <<-PATTERN
+        def_node_search :and_return_value, <<~PATTERN
           $(send _ :and_return $(...))
         PATTERN
 

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

@@ -76,7 +76,7 @@ module RuboCop
           return if first_occurrence == occurrence || !first_occurrence.body
 
           corrector.insert_after(first_occurrence.body,
-                                 "\n#{occurrence.body.source}")
+                                 "\n#{occurrence.body&.source}")
           corrector.remove(range_by_whole_lines(occurrence.source_range,
                                                 include_final_newline: true))
         end

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

@@ -62,7 +62,7 @@ module RuboCop
         PATTERN
 
         # @!method context?(node)
-        def_node_search :context?, <<-PATTERN
+        def_node_search :context?, <<~PATTERN
           (send nil?
             {#Subjects.all #Helpers.all #Includes.context #Hooks.all} ...
           )

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module RSpec
-      # Enforces use of string to titleize shared examples.
+      # Checks for consistent style for shared example names.
       #
-      # @example
+      # Enforces either `string` or `symbol` for shared example names.
+      #
+      # This cop can be configured using the `EnforcedStyle` option
+      #
+      # @example `EnforcedStyle: string` (default)
       #   # bad
       #   it_behaves_like :foo_bar_baz
       #   it_should_behave_like :foo_bar_baz
@@ -20,33 +24,66 @@ module RuboCop
       #   shared_examples_for 'foo bar baz'
       #   include_examples 'foo bar baz'
       #
+      # @example `EnforcedStyle: symbol`
+      #   # bad
+      #   it_behaves_like 'foo bar baz'
+      #   it_should_behave_like 'foo bar baz'
+      #   shared_examples 'foo bar baz'
+      #   shared_examples_for 'foo bar baz'
+      #   include_examples 'foo bar baz'
+      #
+      #   # good
+      #   it_behaves_like :foo_bar_baz
+      #   it_should_behave_like :foo_bar_baz
+      #   shared_examples :foo_bar_baz
+      #   shared_examples_for :foo_bar_baz
+      #   include_examples :foo_bar_baz
+      #
       class SharedExamples < Base
         extend AutoCorrector
+        include ConfigurableEnforcedStyle
 
         # @!method shared_examples(node)
         def_node_matcher :shared_examples, <<~PATTERN
           {
-            (send #rspec? #SharedGroups.all ...)
-            (send nil? #Includes.all ...)
+            (send #rspec? #SharedGroups.all $_ ...)
+            (send nil? #Includes.all $_ ...)
           }
         PATTERN
 
         def on_send(node)
-          shared_examples(node) do
-            ast_node = node.first_argument
-            next unless ast_node&.sym_type?
+          shared_examples(node) do |ast_node|
+            next unless offense?(ast_node)
 
-            checker = Checker.new(ast_node)
-            add_offense(checker.node, message: checker.message) do |corrector|
-              corrector.replace(checker.node, checker.preferred_style)
+            checker = new_checker(ast_node)
+            add_offense(ast_node, message: checker.message) do |corrector|
+              corrector.replace(ast_node, checker.preferred_style)
             end
           end
         end
 
+        private
+
+        def offense?(ast_node)
+          if style == :symbol
+            ast_node.str_type?
+          else # string
+            ast_node.sym_type?
+          end
+        end
+
+        def new_checker(ast_node)
+          if style == :symbol
+            SymbolChecker.new(ast_node)
+          else # string
+            StringChecker.new(ast_node)
+          end
+        end
+
         # :nodoc:
-        class Checker
+        class SymbolChecker
           MSG = 'Prefer %<prefer>s over `%<current>s` ' \
-                'to titleize shared examples.'
+                'to symbolize shared examples.'
 
           attr_reader :node
 
@@ -55,22 +92,31 @@ module RuboCop
           end
 
           def message
-            format(MSG, prefer: preferred_style, current: symbol.inspect)
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
           end
 
           def preferred_style
-            string = symbol.to_s.tr('_', ' ')
-            wrap_with_single_quotes(string)
+            ":#{node.value.to_s.downcase.tr(' ', '_')}"
           end
+        end
+
+        # :nodoc:
+        class StringChecker
+          MSG = 'Prefer %<prefer>s over `%<current>s` ' \
+                'to titleize shared examples.'
 
-          private
+          attr_reader :node
 
-          def symbol
-            node.value
+          def initialize(node)
+            @node = node
           end
 
-          def wrap_with_single_quotes(string)
-            "'#{string}'"
+          def message
+            format(MSG, prefer: preferred_style, current: node.value.inspect)
+          end
+
+          def preferred_style
+            "'#{node.value.to_s.tr('_', ' ')}'"
           end
         end
       end

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

@@ -24,7 +24,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
 
         # @!method message_chain(node)
-        def_node_matcher :message_chain, <<-PATTERN
+        def_node_matcher :message_chain, <<~PATTERN
           (send _ {:receive_message_chain :stub_chain} $_)
         PATTERN
 
@@ -81,8 +81,7 @@ module RuboCop
         end
 
         def key_to_arg(node)
-          key, = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          node.sym_type? ? ":#{key}" : node.source
+          node.sym_type? ? ":#{node.value}" : node.source
         end
 
         def replacement(method)

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

@@ -23,7 +23,8 @@ module RuboCop
 
         MSG = 'Sort metadata alphabetically.'
 
-        def on_metadata(symbols, pairs)
+        def on_metadata(symbols, hash)
+          pairs = hash&.pairs || []
           return if sorted?(symbols, pairs)
 
           crime_scene = crime_scene(symbols, pairs)
@@ -57,7 +58,7 @@ module RuboCop
 
         def sort_symbols(symbols)
           symbols.sort_by do |symbol|
-            if %i[str sym].include?(symbol.type)
+            if symbol.str_type? || symbol.sym_type?
               symbol.value.to_s.downcase
             else
               symbol.source.downcase