rubocop-rspec 1.38.1 → 1.43.0

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

@@ -26,7 +26,8 @@ module RuboCop
       #   # good
       #   it { expect(subject).to be_truthy }
       #
-      class ImplicitSubject < Cop
+      class ImplicitSubject < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = "Don't use implicit subject."
@@ -39,33 +40,37 @@ module RuboCop
           return unless implicit_subject?(node)
           return if valid_usage?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           replacement = 'expect(subject)'
-          if node.method_name == :should
+          case node.method_name
+          when :should
             replacement += '.to'
-          elsif node.method_name == :should_not
+          when :should_not
             replacement += '.not_to'
           end
 
-          ->(corrector) { corrector.replace(node.loc.selector, replacement) }
+          corrector.replace(node.loc.selector, replacement)
         end
 
-        private
-
         def valid_usage?(node)
           example = node.ancestors.find { |parent| example?(parent) }
           return false if example.nil?
 
-          example.method_name == :its || allowed_by_style?(example)
+          example.method?(:its) || allowed_by_style?(example)
         end
 
         def allowed_by_style?(example)
-          if style == :single_line_only
+          case style
+          when :single_line_only
             example.single_line?
-          elsif style == :single_statement_only
+          when :single_statement_only
             !example.body.begin_type?
           else
             false

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

@@ -18,7 +18,9 @@ module RuboCop
       #     expect(foo).to have_received(:bar)
       #   end
       #
-      class InstanceSpy < Cop
+      class InstanceSpy < Base
+        extend AutoCorrector
+
         MSG = 'Use `instance_spy` when you check your double '\
               'with `have_received`.'
 
@@ -43,22 +45,26 @@ module RuboCop
 
           null_double(node) do |var, receiver|
             have_received_usage(node) do |expected|
-              add_offense(receiver) if expected == var
+              next if expected != var
+
+              add_offense(receiver) do |corrector|
+                autocorrect(corrector, receiver)
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = 'instance_spy'
-            corrector.replace(node.loc.selector, replacement)
+        private
 
-            double_source_map = node.parent.loc
-            as_null_object_range = double_source_map
-              .dot
-              .join(double_source_map.selector)
-            corrector.remove(as_null_object_range)
-          end
+        def autocorrect(corrector, node)
+          replacement = 'instance_spy'
+          corrector.replace(node.loc.selector, replacement)
+
+          double_source_map = node.parent.loc
+          as_null_object_range = double_source_map
+            .dot
+            .join(double_source_map.selector)
+          corrector.remove(as_null_object_range)
         end
       end
     end

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

@@ -46,14 +46,12 @@ module RuboCop
       #     it { expect(foo).to be_empty }
       #   end
       #
-      class InstanceVariable < Cop
+      class InstanceVariable < Base
+        include RuboCop::RSpec::TopLevelGroup
+
         MSG = 'Avoid instance variables – use let, ' \
               'a method call, or a local variable (if possible).'
 
-        EXAMPLE_GROUP_METHODS = ExampleGroups::ALL + SharedGroups::ALL
-
-        def_node_matcher :spec_group?, EXAMPLE_GROUP_METHODS.block_pattern
-
         def_node_matcher :dynamic_class?, <<-PATTERN
           (block (send (const nil? :Class) :new ...) ...)
         PATTERN
@@ -69,9 +67,7 @@ module RuboCop
 
         def_node_search :ivar_assigned?, '(ivasgn % ...)'
 
-        def on_block(node)
-          return unless spec_group?(node)
-
+        def on_top_level_group(node)
           ivar_usage(node) do |ivar, name|
             next if valid_usage?(ivar)
             next if assignment_only? && !ivar_assigned?(node, name)

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

@@ -15,7 +15,7 @@ module RuboCop
       #
       #   # good
       #   expect(foo).to be_something
-      class InvalidPredicateMatcher < Cop
+      class InvalidPredicateMatcher < Base
         MSG = 'Omit `?` from `%<matcher>s`.'
 
         def_node_matcher :invalid_predicate_matcher?, <<-PATTERN
@@ -24,7 +24,8 @@ module RuboCop
 
         def on_send(node)
           invalid_predicate_matcher?(node) do |predicate|
-            add_offense(predicate)
+            add_offense(predicate,
+                        message: format(MSG, matcher: predicate.method_name))
           end
         end
 
@@ -34,10 +35,6 @@ module RuboCop
           name = name.to_s
           name.start_with?('be_', 'have_') && name.end_with?('?')
         end
-
-        def message(predicate)
-          format(MSG, matcher: predicate.method_name)
-        end
       end
     end
   end

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

@@ -18,7 +18,8 @@ module RuboCop
       #
       #   # good
       #   it_should_behave_like 'a foo'
-      class ItBehavesLike < Cop
+      class ItBehavesLike < Base
+        extend AutoCorrector
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<replacement>s` over `%<original>s` when including '\
@@ -28,14 +29,12 @@ module RuboCop
 
         def on_send(node)
           example_inclusion_offense(node, alternative_style) do
-            add_offense(node)
+            add_offense(node) 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/iterated_expectation.rb

@@ -15,7 +15,7 @@ module RuboCop
       #   it 'validates users' do
       #     expect([user1, user2, user3]).to all(be_valid)
       #   end
-      class IteratedExpectation < Cop
+      class IteratedExpectation < Base
         MSG = 'Prefer using the `all` matcher instead ' \
                   'of iterating over an array.'
 

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

@@ -31,8 +31,8 @@ module RuboCop
       #     it { expect_something }
       #     it { expect_something_else }
       #
-      class LeadingSubject < Cop
-        include RangeHelp
+      class LeadingSubject < Base
+        extend AutoCorrector
 
         MSG = 'Declare `subject` above any other `%<offending>s` declarations.'
 
@@ -43,40 +43,36 @@ module RuboCop
         end
 
         def check_previous_nodes(node)
-          node.parent.each_child_node do |sibling|
-            if offending?(sibling)
-              add_offense(
-                node,
-                message: format(MSG, offending: sibling.method_name)
-              )
+          offending_node(node) do |offender|
+            msg = format(MSG, offending: offender.method_name)
+            add_offense(node, message: msg) do |corrector|
+              autocorrect(corrector, node, offender)
             end
-
-            break if offending?(sibling) || sibling.equal?(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            first_node = find_first_offending_node(node)
-            first_node_position = first_node.loc.expression
-            indent = "\n" + ' ' * first_node.loc.column
-            corrector.insert_before(first_node_position, node.source + indent)
-            corrector.remove(node_range(node))
           end
         end
 
         private
 
-        def offending?(node)
-          let?(node) || hook?(node) || example?(node)
+        def offending_node(node)
+          node.parent.each_child_node.find do |sibling|
+            break if sibling.equal?(node)
+
+            yield sibling if offending?(sibling)
+          end
         end
 
-        def find_first_offending_node(node)
-          node.parent.children.find { |sibling| offending?(sibling) }
+        def autocorrect(corrector, node, sibling)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(sibling)
         end
 
-        def node_range(node)
-          range_by_whole_lines(node.source_range, include_final_newline: true)
+        def offending?(node)
+          let?(node) ||
+            hook?(node) ||
+            example?(node) ||
+            spec_group?(node) ||
+            include?(node)
         end
 
         def in_spec_block?(node)

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

@@ -93,7 +93,7 @@ module RuboCop
       #       stub_const('SomeModule::SomeClass', foo_class)
       #     end
       #   end
-      class LeakyConstantDeclaration < Cop
+      class LeakyConstantDeclaration < Base
         MSG_CONST = 'Stub constant instead of declaring explicitly.'
         MSG_CLASS = 'Stub class constant instead of declaring explicitly.'
         MSG_MODULE = 'Stub module constant instead of declaring explicitly.'
@@ -119,11 +119,8 @@ module RuboCop
         private
 
         def inside_describe_block?(node)
-          node.each_ancestor(:block).any?(&method(:in_example_or_shared_group?))
+          node.each_ancestor(:block).any?(&method(:spec_group?))
         end
-
-        def_node_matcher :in_example_or_shared_group?,
-                         (ExampleGroups::ALL + SharedGroups::ALL).block_pattern
       end
     end
   end

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

@@ -30,9 +30,8 @@ module RuboCop
       #   it 'checks what some does' do
       #     expect(some).to be
       #   end
-      class LetBeforeExamples < Cop
-        include RangeHelp
-        include RuboCop::RSpec::FinalEndLocation
+      class LetBeforeExamples < Base
+        extend AutoCorrector
 
         MSG = 'Move `let` before the examples in the group.'
 
@@ -49,17 +48,6 @@ module RuboCop
           check_let_declarations(node.body) if multiline_block?(node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            first_example = find_first_example(node.parent)
-            first_example_pos = first_example.loc.expression
-            indent = "\n" + ' ' * first_example.loc.column
-
-            corrector.insert_before(first_example_pos, source(node) + indent)
-            corrector.remove(node_range_with_surrounding_space(node))
-          end
-        end
-
         private
 
         def multiline_block?(block)
@@ -72,8 +60,11 @@ module RuboCop
 
           node.each_child_node do |child|
             next if child.sibling_index < first_example.sibling_index
+            next unless let?(child)
 
-            add_offense(child) if let?(child)
+            add_offense(child) do |corrector|
+              autocorrect(corrector, child, first_example)
+            end
           end
         end
 
@@ -81,17 +72,10 @@ module RuboCop
           node.children.find { |sibling| example_or_group?(sibling) }
         end
 
-        def node_range_with_surrounding_space(node)
-          range = node_range(node)
-          range_by_whole_lines(range, include_final_newline: true)
-        end
-
-        def source(node)
-          node_range(node).source
-        end
-
-        def node_range(node)
-          node.loc.expression.with(end_pos: final_end_location(node).end_pos)
+        def autocorrect(corrector, node, first_example)
+          RuboCop::RSpec::Corrector::MoveNode.new(
+            node, corrector, processed_source
+          ).move_before(first_example)
         end
       end
     end

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

@@ -25,17 +25,26 @@ module RuboCop
       #   it 'counts widgets' do
       #     expect(Widget.count).to eq(1)
       #   end
-      class LetSetup < Cop
+      class LetSetup < Base
         MSG = 'Do not use `let!` to setup objects not referenced in tests.'
 
-        def_node_search :let_bang, <<-PATTERN
-          (block $(send nil? :let! (sym $_)) args ...)
+        def_node_matcher :example_or_shared_group_or_including?,
+                         (
+                           ExampleGroups::ALL + SharedGroups::ALL +
+                           Includes::ALL
+                         ).block_pattern
+
+        def_node_matcher :let_bang, <<-PATTERN
+          {
+            (block $(send nil? :let! {(sym $_) (str $_)}) ...)
+            $(send nil? :let! {(sym $_) (str $_)} block_pass)
+          }
         PATTERN
 
         def_node_search :method_called?, '(send nil? %)'
 
         def on_block(node)
-          return unless example_group?(node)
+          return unless example_or_shared_group_or_including?(node)
 
           unused_let_bang(node) do |let|
             add_offense(let)
@@ -45,8 +54,14 @@ module RuboCop
         private
 
         def unused_let_bang(node)
-          let_bang(node) do |method_send, method_name|
-            yield(method_send) unless method_called?(node, method_name)
+          child_let_bang(node) do |method_send, method_name|
+            yield(method_send) unless method_called?(node, method_name.to_sym)
+          end
+        end
+
+        def child_let_bang(node, &block)
+          RuboCop::RSpec::ExampleGroup.new(node).lets.each do |let|
+            let_bang(let, &block)
           end
         end
       end

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

@@ -13,7 +13,7 @@ module RuboCop
       #   thing = Thing.new(baz: 42)
       #   allow(foo).to receive(:bar).and_return(thing)
       #
-      class MessageChain < Cop
+      class MessageChain < Base
         MSG = 'Avoid stubbing using `%<method>s`.'
 
         def_node_matcher :message_chain, <<-PATTERN
@@ -21,11 +21,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          message_chain(node) { add_offense(node, location: :selector) }
-        end
-
-        def message(node)
-          format(MSG, method: node.method_name)
+          message_chain(node) do
+            add_offense(
+              node.loc.selector,
+              message: format(MSG, method: node.method_name)
+            )
+          end
         end
       end
     end

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

@@ -24,7 +24,7 @@ module RuboCop
       #   # good
       #   expect(foo).to receive(:bar)
       #
-      class MessageExpectation < Cop
+      class MessageExpectation < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Prefer `%<style>s` for setting message expectations.'
@@ -42,7 +42,7 @@ module RuboCop
             return correct_style_detected if preferred_style?(match)
 
             message = format(MSG, style: style)
-            add_offense(match, location: :selector, message: message) do
+            add_offense(match.loc.selector, message: message) do
               opposite_style_detected
             end
           end