rubocop-rspec 2.0.0.pre → 2.3.0

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

@@ -20,25 +20,43 @@ module RuboCop
       #   describe MyClass do
       #   end
       class Focus < Base
-        MSG = 'Focused spec found.'
+        extend AutoCorrector
+        include RangeHelp
 
-        focused = ExampleGroups::FOCUSED + Examples::FOCUSED
+        MSG = 'Focused spec found.'
 
-        def_node_matcher :focusable_selector?,
-                         (ExampleGroups::GROUPS + ExampleGroups::SKIPPED +
-                          Examples::EXAMPLES + Examples::SKIPPED +
-                          Examples::PENDING).node_pattern_union
+        # @!method focusable_selector?(node)
+        def_node_matcher :focusable_selector?, <<-PATTERN
+          {
+            #ExampleGroups.regular
+            #ExampleGroups.skipped
+            #Examples.regular
+            #Examples.skipped
+            #Examples.pending
+          }
+        PATTERN
 
+        # @!method metadata(node)
         def_node_matcher :metadata, <<-PATTERN
           {(send #rspec? #focusable_selector? <$(sym :focus) ...>)
            (send #rspec? #focusable_selector? ... (hash <$(pair (sym :focus) true) ...>))}
         PATTERN
 
-        def_node_matcher :focused_block?, focused.send_pattern
+        # @!method focused_block?(node)
+        def_node_matcher :focused_block?,
+                         send_pattern(<<~PATTERN)
+                           {#ExampleGroups.focused #Examples.focused}
+                         PATTERN
 
         def on_send(node)
           focus_metadata(node) do |focus|
-            add_offense(focus)
+            add_offense(focus) do |corrector|
+              if focus.pair_type? || focus.str_type? || focus.sym_type?
+                corrector.remove(with_surrounding(focus))
+              elsif focus.send_type?
+                correct_send(corrector, focus)
+              end
+            end
           end
         end
 
@@ -49,6 +67,26 @@ module RuboCop
 
           metadata(node, &block)
         end
+
+        def with_surrounding(focus)
+          range_with_space = range_with_surrounding_space(
+            range: focus.loc.expression,
+            side: :left
+          )
+
+          range_with_surrounding_comma(range_with_space, :left)
+        end
+
+        def correct_send(corrector, focus)
+          range = focus.loc.selector
+          unfocused = focus.method_name.to_s.sub(/^f/, '')
+          unless Examples.regular(unfocused) || ExampleGroups.regular(unfocused)
+            return
+          end
+
+          corrector.replace(range,
+                            range.source.sub(focus.method_name.to_s, unfocused))
+        end
       end
     end
   end

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

@@ -64,13 +64,13 @@ module RuboCop
         IMPLICIT_MSG = 'Omit the default `%<scope>p` argument for RSpec hooks.'
         EXPLICIT_MSG = 'Use `%<scope>p` for RSpec hooks.'
 
-        def_node_matcher :hook?, Hooks::ALL.node_pattern_union
-
+        # @!method scoped_hook(node)
         def_node_matcher :scoped_hook, <<-PATTERN
-          (block $(send _ #hook? (sym ${:each :example})) ...)
+          (block $(send _ #Hooks.all (sym ${:each :example})) ...)
         PATTERN
 
-        def_node_matcher :unscoped_hook, '(block $(send _ #hook?) ...)'
+        # @!method unscoped_hook(node)
+        def_node_matcher :unscoped_hook, '(block $(send _ #Hooks.all) ...)'
 
         def on_block(node)
           hook(node) do |method_send, scope_name|

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

@@ -28,10 +28,11 @@ module RuboCop
 
         MSG = 'Move `%<hook>s` above the examples in the group.'
 
+        # @!method example_or_group?(node)
         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/implicit_block_expectation.rb

@@ -18,7 +18,9 @@ module RuboCop
       #   end
       class ImplicitBlockExpectation < Base
         MSG = 'Avoid implicit block expectations.'
+        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
 
+        # @!method lambda?(node)
         def_node_matcher :lambda?, <<-PATTERN
           {
             (send (const nil? :Proc) :new)
@@ -26,8 +28,10 @@ module RuboCop
           }
         PATTERN
 
+        # @!method lambda_subject?(node)
         def_node_matcher :lambda_subject?, '(block #lambda? ...)'
 
+        # @!method implicit_expect(node)
         def_node_matcher :implicit_expect, <<-PATTERN
           $(send nil? {:is_expected :should :should_not} ...)
         PATTERN

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

@@ -30,10 +30,11 @@ module RuboCop
 
         MSG = 'Prefer `%<good>s` over `%<bad>s`.'
 
+        # @!method implicit_expect(node)
         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/implicit_subject.rb

@@ -31,7 +31,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = "Don't use implicit subject."
+        RESTRICT_ON_SEND = %i[is_expected should should_not].freeze
 
+        # @!method implicit_subject?(node)
         def_node_matcher :implicit_subject?, <<-PATTERN
           (send nil? {:should :should_not :is_expected} ...)
         PATTERN

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

@@ -21,9 +21,10 @@ module RuboCop
       class InstanceSpy < Base
         extend AutoCorrector
 
-        MSG = 'Use `instance_spy` when you check your double '\
+        MSG = 'Use `instance_spy` when you check your double ' \
               'with `have_received`.'
 
+        # @!method null_double(node)
         def_node_search :null_double, <<-PATTERN
           (lvasgn $_
             (send
@@ -31,6 +32,7 @@ module RuboCop
                 ...) :as_null_object))
         PATTERN
 
+        # @!method have_received_usage(node)
         def_node_search :have_received_usage, <<-PATTERN
           (send
             (send nil? :expect

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

@@ -47,15 +47,17 @@ 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).'
 
+        # @!method dynamic_class?(node)
         def_node_matcher :dynamic_class?, <<-PATTERN
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
 
+        # @!method custom_matcher?(node)
         def_node_matcher :custom_matcher?, <<-PATTERN
           (block {
             (send nil? :matcher sym)
@@ -63,8 +65,10 @@ module RuboCop
           } ...)
         PATTERN
 
+        # @!method ivar_usage(node)
         def_node_search :ivar_usage, '$(ivar $_)'
 
+        # @!method ivar_assigned?(node)
         def_node_search :ivar_assigned?, '(ivasgn % ...)'
 
         def on_top_level_group(node)

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

@@ -22,9 +22,11 @@ module RuboCop
         extend AutoCorrector
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including '\
+        MSG = 'Prefer `%<replacement>s` over `%<original>s` when including ' \
               'examples in a nested context.'
+        RESTRICT_ON_SEND = %i[it_behaves_like it_should_behave_like].freeze
 
+        # @!method example_inclusion_offense(node)
         def_node_matcher :example_inclusion_offense, '(send _ % ...)'
 
         def on_send(node)

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

@@ -17,8 +17,9 @@ module RuboCop
       #   end
       class IteratedExpectation < Base
         MSG = 'Prefer using the `all` matcher instead ' \
-                  'of iterating over an array.'
+              'of iterating over an array.'
 
+        # @!method each?(node)
         def_node_matcher :each?, <<-PATTERN
           (block
             (send ... :each)
@@ -27,6 +28,7 @@ module RuboCop
           )
         PATTERN
 
+        # @!method expectation?(node)
         def_node_matcher :expectation?, <<-PATTERN
           (send (send nil? :expect (lvar %)) :to ...)
         PATTERN

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

@@ -35,10 +35,11 @@ module RuboCop
 
         MSG = 'Move `let` before the examples in the group.'
 
+        # @!method example_or_group?(node)
         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

@@ -28,12 +28,17 @@ module RuboCop
       class LetSetup < Base
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
+        # @!method example_or_shared_group_or_including?(node)
         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
 
+        # @!method let_bang(node)
         def_node_matcher :let_bang, <<-PATTERN
           {
             (block $(send nil? :let! {(sym $_) (str $_)}) ...)
@@ -41,6 +46,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method method_called?(node)
         def_node_search :method_called?, '(send nil? %)'
 
         def on_block(node)

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

@@ -15,18 +15,12 @@ module RuboCop
       #
       class MessageChain < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
-
-        def_node_matcher :message_chain, <<-PATTERN
-          (send _ {:receive_message_chain :stub_chain} ...)
-        PATTERN
+        RESTRICT_ON_SEND = %i[receive_message_chain stub_chain].freeze
 
         def on_send(node)
-          message_chain(node) do
-            add_offense(
-              node.loc.selector,
-              message: format(MSG, method: node.method_name)
-            )
-          end
+          add_offense(
+            node.loc.selector, message: format(MSG, method: node.method_name)
+          )
         end
       end
     end

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

@@ -30,11 +30,14 @@ 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
           (send $(send nil? {:expect :allow} ...) :to #receive_message?)
         PATTERN
 
+        # @!method receive_message?(node)
         def_node_search :receive_message?, '(send nil? :receive ...)'
 
         def on_send(node)

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

@@ -29,16 +29,18 @@ module RuboCop
 
         MSG_RECEIVE = 'Prefer `receive` for setting message expectations.'
 
-        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message '\
-                            'expectations. Setup `%<source>s` as a spy using '\
+        MSG_HAVE_RECEIVED = 'Prefer `have_received` for setting message ' \
+                            'expectations. Setup `%<source>s` as a spy using ' \
                             '`allow` or `instance_spy`.'
 
         SUPPORTED_STYLES = %w[have_received receive].freeze
 
+        # @!method message_expectation(node)
         def_node_matcher :message_expectation, %(
-          (send (send nil? :expect $_) #{Runners::ALL.node_pattern_union} ...)
+          (send (send nil? :expect $_) #Runners.all ...)
         )
 
+        # @!method receive_message(node)
         def_node_search :receive_message, %(
           $(send nil? {:receive :have_received} ...)
         )

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Help methods for working with nodes containing comments.
+      module CommentsHelp
+        include FinalEndLocation
+
+        def source_range_with_comment(node)
+          begin_pos = begin_pos_with_comment(node).begin_pos
+          end_pos = end_line_position(node).end_pos
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def begin_pos_with_comment(node)
+          first_comment = processed_source.ast_with_comments[node].first
+
+          start_line_position(first_comment || node)
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line)
+        end
+
+        def end_line_position(node)
+          end_line = buffer.line_for_position(final_end_location(node).end_pos)
+          buffer.line_range(end_line)
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+      end
+    end
+  end
+end

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