rubocop-rspec 2.4.0 → 2.8.0

data/lib/rubocop/cop/rspec/capybara/current_path_expectation.rb

@@ -6,13 +6,13 @@ module RuboCop
       module Capybara
         # Checks that no expectations are set on Capybara's `current_path`.
         #
-        # The `have_current_path` matcher (https://www.rubydoc.info/github/
-        # teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-
-        # instance_method) should be used on `page` to set expectations on
-        # Capybara's current path, since it uses Capybara's waiting
-        # functionality (https://github.com/teamcapybara/capybara/blob/master/
-        # README.md#asynchronous-javascript-ajax-and-friends) which ensures that
-        # preceding actions (like `click_link`) have completed.
+        # The
+        # https://www.rubydoc.info/github/teamcapybara/capybara/master/Capybara/RSpecMatchers#have_current_path-instance_method[`have_current_path` matcher]
+        # should be used on `page` to set expectations on Capybara's
+        # current path, since it uses
+        # https://github.com/teamcapybara/capybara/blob/master/README.md#asynchronous-javascript-ajax-and-friends[Capybara's waiting functionality]
+        # which ensures that preceding actions (like `click_link`) have
+        # completed.
         #
         # @example
         #   # bad

data/lib/rubocop/cop/rspec/capybara/feature_methods.rb

@@ -42,6 +42,7 @@ module RuboCop
         #   end
         class FeatureMethods < Base
           extend AutoCorrector
+          include InsideExampleGroup
 
           MSG = 'Use `%<replacement>s` instead of `%<method>s`.'
 
@@ -60,13 +61,6 @@ module RuboCop
             {#{MAP.keys.map(&:inspect).join(' ')}}
           PATTERN
 
-          # @!method spec?(node)
-          def_node_matcher :spec?, <<-PATTERN
-            (block
-              (send #rspec? {:describe :feature} ...)
-            ...)
-          PATTERN
-
           # @!method feature_method(node)
           def_node_matcher :feature_method, <<-PATTERN
             (block
@@ -75,7 +69,7 @@ module RuboCop
           PATTERN
 
           def on_block(node)
-            return unless inside_spec?(node)
+            return unless inside_example_group?(node)
 
             feature_method(node) do |send_node, match|
               next if enabled?(match)
@@ -93,21 +87,6 @@ module RuboCop
 
           private
 
-          def inside_spec?(node)
-            return spec?(node) if root_node?(node)
-
-            root = node.ancestors.find { |parent| root_node?(parent) }
-            spec?(root)
-          end
-
-          def root_node?(node)
-            node.parent.nil? || root_with_siblings?(node.parent)
-          end
-
-          def root_with_siblings?(node)
-            node.begin_type? && node.parent.nil?
-          end
-
           def enabled?(method_name)
             enabled_methods.include?(method_name)
           end

data/lib/rubocop/cop/rspec/capybara/visibility_matcher.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module RSpec
       module Capybara
-        # Checks for boolean visibility in capybara finders.
+        # Checks for boolean visibility in Capybara finders.
         #
         # Capybara lets you find elements that match a certain visibility using
         # the `:visible` option. `:visible` accepts both boolean and symbols as
@@ -12,7 +12,8 @@ module RuboCop
         # false` does not find just invisible elements, but both visible and
         # invisible elements. For expressiveness and clarity, use one of the
         # symbol values, `:all`, `:hidden` or `:visible`.
-        # (https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all)
+        # Read more in
+        # https://www.rubydoc.info/gems/capybara/Capybara%2FNode%2FFinders:all[the documentation].
         #
         # @example
         #

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

@@ -36,7 +36,10 @@ module RuboCop
         def on_block(node)
           empty_hook?(node) do |hook|
             add_offense(hook) do |corrector|
-              range = range_with_surrounding_space(range: node.loc.expression)
+              range = range_with_surrounding_space(
+                range: node.loc.expression,
+                side: :left
+              )
               corrector.remove(range)
             end
           end

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

@@ -17,24 +17,18 @@ module RuboCop
       class EmptyLineAfterSubject < Base
         extend AutoCorrector
         include EmptyLineSeparation
+        include InsideExampleGroup
 
         MSG = 'Add an empty line after `%<subject>s`.'
 
         def on_block(node)
-          return unless subject?(node) && !in_spec_block?(node)
+          return unless subject?(node)
+          return unless inside_example_group?(node)
 
           missing_separating_line_offense(node) do |method|
             format(MSG, subject: method)
           end
         end
-
-        private
-
-        def in_spec_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            Examples.all(ancestor.method_name)
-          end
-        end
       end
     end
   end

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

@@ -60,7 +60,10 @@ module RuboCop
 
         def add_wording_offense(node, message)
           docstring = docstring(node)
+
           add_offense(docstring, message: message) do |corrector|
+            next if node.heredoc?
+
             corrector.replace(docstring, replacement_text(node))
           end
         end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Checks for excessive whitespace in example descriptions.
+      #
+      # @example
+      #   # bad
+      #   it '  has  excessive   spacing  ' do
+      #   end
+      #
+      #   # good
+      #   it 'has excessive spacing' do
+      #   end
+      #
+      # @example
+      #   # bad
+      #   context '  when a condition   is met  ' do
+      #   end
+      #
+      #   # good
+      #   context 'when a condition is met' do
+      #   end
+      class ExcessiveDocstringSpacing < Base
+        extend AutoCorrector
+
+        MSG = 'Excessive whitespace.'
+
+        # @!method example_description(node)
+        def_node_matcher :example_description, <<-PATTERN
+          (send _ {#Examples.all #ExampleGroups.all} ${
+            $str
+            $(dstr ({str dstr `sym} ...) ...)
+          } ...)
+        PATTERN
+
+        def on_send(node)
+          example_description(node) do |description_node, message|
+            return if description_node.heredoc?
+
+            text = text(message)
+
+            return unless excessive_whitespace?(text)
+
+            add_whitespace_offense(description_node, text)
+          end
+        end
+
+        private
+
+        # @param text [String]
+        def excessive_whitespace?(text)
+          return true if text.start_with?(' ') || text.end_with?(' ')
+
+          text.match?(/[^\n ]  +[^ ]/)
+        end
+
+        # @param text [String]
+        def strip_excessive_whitespace(text)
+          text.strip.gsub(/  +/, ' ')
+        end
+
+        # @param node [RuboCop::AST::Node]
+        # @param text [String]
+        def add_whitespace_offense(node, text)
+          docstring = docstring(node)
+          corrected = strip_excessive_whitespace(text)
+
+          add_offense(docstring) do |corrector|
+            corrector.replace(docstring, corrected)
+          end
+        end
+
+        def docstring(node)
+          expr = node.loc.expression
+
+          Parser::Source::Range.new(
+            expr.source_buffer,
+            expr.begin_pos + 1,
+            expr.end_pos - 1
+          )
+        end
+
+        # Recursive processing is required to process nested dstr nodes
+        # that is the case for \-separated multiline strings with interpolation.
+        def text(node)
+          case node.type
+          when :dstr
+            node.node_parts.map { |child_node| text(child_node) }.join
+          when :str, :sym
+            node.value
+          when :begin
+            node.source
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/factory_bot/create_list.rb

@@ -27,6 +27,7 @@ module RuboCop
         class CreateList < Base
           extend AutoCorrector
           include ConfigurableEnforcedStyle
+          include RuboCop::RSpec::FactoryBot::Language
 
           MSG_CREATE_LIST = 'Prefer create_list.'
           MSG_N_TIMES = 'Prefer %<number>s.times.'
@@ -43,12 +44,12 @@ module RuboCop
 
           # @!method factory_call(node)
           def_node_matcher :factory_call, <<-PATTERN
-            (send ${(const nil? {:FactoryGirl :FactoryBot}) nil?} :create (sym $_) $...)
+            (send ${nil? #factory_bot?} :create (sym $_) $...)
           PATTERN
 
           # @!method factory_list_call(node)
           def_node_matcher :factory_list_call, <<-PATTERN
-            (send {(const nil? {:FactoryGirl :FactoryBot}) nil?} :create_list (sym _) (int $_) ...)
+            (send {nil? #factory_bot?} :create_list (sym _) (int $_) ...)
           PATTERN
 
           def on_block(node)
@@ -160,7 +161,7 @@ module RuboCop
             def call_with_block_replacement(node)
               block = node.body
               arguments = build_arguments(block, node.receiver.source)
-              replacement = format_receiver(block.send_node.receiver)
+              replacement = format_receiver(block.receiver)
               replacement += format_method_call(block, 'create_list', arguments)
               replacement += format_block(block)
               replacement

data/lib/rubocop/cop/rspec/factory_bot/syntax_methods.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      module FactoryBot
+        # Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
+        #
+        # @safety
+        #   The auto-correction is marked as unsafe because the cop
+        #   cannot verify whether you already include
+        #   `FactoryBot::Syntax::Methods` in your test suite.
+        #
+        #   If you're using Rails, add the following configuration to
+        #   `spec/support/factory_bot.rb` and be sure to require that file in
+        #   `rails_helper.rb`:
+        #
+        #   [source,ruby]
+        #   ----
+        #   RSpec.configure do |config|
+        #     config.include FactoryBot::Syntax::Methods
+        #   end
+        #   ----
+        #
+        #   If you're not using Rails:
+        #
+        #   [source,ruby]
+        #   ----
+        #   RSpec.configure do |config|
+        #     config.include FactoryBot::Syntax::Methods
+        #
+        #     config.before(:suite) do
+        #       FactoryBot.find_definitions
+        #     end
+        #   end
+        #   ----
+        #
+        # @example
+        #   # bad
+        #   FactoryBot.create(:bar)
+        #   FactoryBot.build(:bar)
+        #   FactoryBot.attributes_for(:bar)
+        #
+        #   # good
+        #   create(:bar)
+        #   build(:bar)
+        #   attributes_for(:bar)
+        #
+        class SyntaxMethods < Base
+          extend AutoCorrector
+          include InsideExampleGroup
+          include RangeHelp
+          include RuboCop::RSpec::FactoryBot::Language
+
+          MSG = 'Use `%<method>s` from `FactoryBot::Syntax::Methods`.'
+
+          RESTRICT_ON_SEND = %i[
+            attributes_for
+            attributes_for_list
+            attributes_for_pair
+            build
+            build_list
+            build_pair
+            build_stubbed
+            build_stubbed_list
+            build_stubbed_pair
+            create
+            create_list
+            create_pair
+            generate
+            generate_list
+            null
+            null_list
+            null_pair
+          ].to_set.freeze
+
+          def on_send(node)
+            return unless factory_bot?(node.receiver)
+            return unless inside_example_group?(node)
+
+            message = format(MSG, method: node.method_name)
+
+            add_offense(crime_scene(node), message: message) do |corrector|
+              corrector.remove(offense(node))
+            end
+          end
+
+          private
+
+          def crime_scene(node)
+            range_between(
+              node.loc.expression.begin_pos,
+              node.loc.selector.end_pos
+            )
+          end
+
+          def offense(node)
+            range_between(
+              node.loc.expression.begin_pos,
+              node.loc.selector.begin_pos
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module RuboCop
       #     # ...
       #   end
       #
-      #   # good
+      #   # bad
       #   before do
       #     # ...
       #   end

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

@@ -48,6 +48,8 @@ module RuboCop
         end
 
         def only_expectations?(body, arg)
+          return false unless body.each_child_node.any?
+
           body.each_child_node.all? { |child| expectation?(child, arg) }
         end
       end

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

@@ -33,11 +33,13 @@ module RuboCop
       #
       class LeadingSubject < Base
         extend AutoCorrector
+        include InsideExampleGroup
 
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
         def on_block(node)
-          return unless subject?(node) && !in_spec_block?(node)
+          return unless subject?(node)
+          return unless inside_example_group?(node)
 
           check_previous_nodes(node)
         end
@@ -78,12 +80,6 @@ module RuboCop
             spec_group?(node) ||
             include?(node)
         end
-
-        def in_spec_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            example?(ancestor)
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Helps you identify whether a given node
+      # is within an example group or not.
+      module InsideExampleGroup
+        private
+
+        def inside_example_group?(node)
+          return spec_group?(node) if example_group_root?(node)
+
+          root = node.ancestors.find { |parent| example_group_root?(parent) }
+
+          spec_group?(root)
+        end
+
+        def example_group_root?(node)
+          node.parent.nil? || example_group_root_with_siblings?(node.parent)
+        end
+
+        def example_group_root_with_siblings?(node)
+          node.begin_type? && node.parent.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for nested example groups.
       #
       # This cop is configurable using the `Max` option
-      # and supports `--auto-gen-config
+      # and supports `--auto-gen-config`.
       #
       # @example
       #   # bad

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensure that subject is defined using subject helper.
+      #
+      # @example
+      #
+      #   # bad
+      #   let(:subject) { foo }
+      #   let!(:subject) { foo }
+      #   subject(:subject) { foo }
+      #   subject!(:subject) { foo }
+      #
+      #   # bad
+      #   block = -> {}
+      #   let(:subject, &block)
+      #
+      #   # good
+      #   subject(:test_subject) { foo }
+      #
+      class SubjectDeclaration < Base
+        MSG_LET = 'Use subject explicitly rather than using let'
+        MSG_REDUNDANT = 'Ambiguous declaration of subject'
+
+        # @!method offensive_subject_declaration?(node)
+        def_node_matcher :offensive_subject_declaration?, <<~PATTERN
+          (send nil? ${#Subjects.all #Helpers.all} {(sym :subject) (str "subject")} ...)
+        PATTERN
+
+        def on_send(node)
+          offense = offensive_subject_declaration?(node)
+          return unless offense
+
+          add_offense(node, message: message_for(offense))
+        end
+
+        private
+
+        def message_for(offense)
+          Helpers.all(offense) ? MSG_LET : MSG_REDUNDANT
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,9 @@ module RuboCop
     module RSpec
       # Checks for stubbed test subjects.
       #
+      # Checks nested subject stubs for innermost subject definition
+      # when subject is also defined in parent example groups.
+      #
       # @see https://robots.thoughtbot.com/don-t-stub-the-system-under-test
       # @see https://samphippen.com/introducing-rspec-smells-and-where-to-find-them#smell-1-stubject
       # @see https://github.com/rubocop-hq/rspec-style-guide#dont-stub-subject
@@ -22,6 +25,20 @@ module RuboCop
       #     end
       #   end
       #
+      #   # bad
+      #   describe Article do
+      #     subject(:foo) { Article.new }
+      #
+      #     context 'nested subject' do
+      #       subject(:article) { Article.new }
+      #
+      #       it 'indicates that the author is unknown' do
+      #         allow(article).to receive(:author).and_return(nil)
+      #         expect(article.description).to include('by an unknown author')
+      #       end
+      #     end
+      #   end
+      #
       #   # good
       #   describe Article do
       #     subject(:article) { Article.new(author: nil) }
@@ -36,27 +53,35 @@ module RuboCop
 
         MSG = 'Do not stub methods of the object under test.'
 
-        # @!method subject(node)
+        # @!method subject?(node)
         #   Find a named or unnamed subject definition
         #
         #   @example anonymous subject
-        #     subject(parse('subject { foo }').ast) do |name|
+        #     subject?(parse('subject { foo }').ast) do |name|
         #       name # => :subject
         #     end
         #
         #   @example named subject
-        #     subject(parse('subject(:thing) { foo }').ast) do |name|
+        #     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?
-                {:subject (sym $_) | $:subject}
-              ) args ...)
+        def_node_matcher :subject?, <<-PATTERN
+          (block
+            (send nil?
+              {:subject (sym $_) | $:subject}
+            ) args ...)
+        PATTERN
+
+        # @!method let?(node)
+        #   Find a memoized helper
+        def_node_matcher :let?, <<-PATTERN
+          (block
+            (send nil? :let (sym $_)
+            ) args ...)
         PATTERN
 
         # @!method message_expectation?(node, method_name)
@@ -73,7 +98,7 @@ module RuboCop
         def_node_matcher :message_expectation?, <<-PATTERN
           (send
             {
-              (send nil? { :expect :allow } (send nil? {% :subject}))
+              (send nil? { :expect :allow } (send nil? %))
               (send nil? :is_expected)
             }
             #Runners.all
@@ -89,7 +114,8 @@ module RuboCop
         PATTERN
 
         def on_top_level_group(node)
-          @explicit_subjects = find_all_explicit_subjects(node)
+          @explicit_subjects = find_all_explicit(node, &method(:subject?))
+          @subject_overrides = find_all_explicit(node, &method(:let?))
 
           find_subject_expectations(node) do |stub|
             add_offense(stub)
@@ -98,12 +124,12 @@ module RuboCop
 
         private
 
-        def find_all_explicit_subjects(node)
+        def find_all_explicit(node)
           node.each_descendant(:block).with_object({}) do |child, h|
-            name = subject(child)
+            name = yield(child)
             next unless name
 
-            outer_example_group = child.each_ancestor.find do |a|
+            outer_example_group = child.each_ancestor(:block).find do |a|
               example_group?(a)
             end
 
@@ -113,14 +139,14 @@ module RuboCop
         end
 
         def find_subject_expectations(node, subject_names = [], &block)
-          subject_names = @explicit_subjects[node] if @explicit_subjects[node]
+          subject_names = [*subject_names, *@explicit_subjects[node]]
+          subject_names -= @subject_overrides[node] if @subject_overrides[node]
 
-          expectation_detected = (subject_names + [:subject]).any? do |name|
-            message_expectation?(node, name)
-          end
+          names = Set[*subject_names, :subject]
+          expectation_detected = message_expectation?(node, names)
           return yield(node) if expectation_detected
 
-          node.each_child_node do |child|
+          node.each_child_node(:send, :def, :block, :begin) do |child|
             find_subject_expectations(child, subject_names, &block)
           end
         end