rubocop 0.87.1 → 0.91.0

data/lib/rubocop/cop/style/negated_if.rb

@@ -68,19 +68,19 @@ module RuboCop
       #   if !foo
       #     bar
       #   end
-      class NegatedIf < Cop
+      class NegatedIf < Base
         include ConfigurableEnforcedStyle
         include NegativeConditional
+        extend AutoCorrector
 
         def on_if(node)
           return if node.unless? || node.elsif? || node.ternary?
           return if correct_style?(node)
 
-          check_negative_conditional(node)
-        end
-
-        def autocorrect(node)
-          ConditionCorrector.correct_negative_condition(node)
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
 
         private

data/lib/rubocop/cop/style/negated_unless.rb

@@ -58,19 +58,19 @@ module RuboCop
       #   unless !foo
       #     bar
       #   end
-      class NegatedUnless < Cop
+      class NegatedUnless < Base
         include ConfigurableEnforcedStyle
         include NegativeConditional
+        extend AutoCorrector
 
         def on_if(node)
           return if node.if? || node.elsif? || node.ternary?
           return if correct_style?(node)
 
-          check_negative_conditional(node)
-        end
-
-        def autocorrect(node)
-          ConditionCorrector.correct_negative_condition(node)
+          message = message(node)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
 
         private

data/lib/rubocop/cop/style/negated_while.rb

@@ -22,26 +22,18 @@ module RuboCop
       #   # good
       #   bar while foo
       #   bar while !foo && baz
-      class NegatedWhile < Cop
+      class NegatedWhile < Base
         include NegativeConditional
+        extend AutoCorrector
 
         def on_while(node)
-          check_negative_conditional(node)
-        end
-
-        def on_until(node)
-          check_negative_conditional(node)
-        end
-
-        def autocorrect(node)
-          ConditionCorrector.correct_negative_condition(node)
-        end
-
-        private
+          message = format(MSG, inverse: node.inverse_keyword, current: node.keyword)
 
-        def message(node)
-          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+          check_negative_conditional(node, message: message) do |corrector|
+            ConditionCorrector.correct_negative_condition(corrector, node)
+          end
         end
+        alias on_until on_while
       end
     end
   end

data/lib/rubocop/cop/style/nested_modifier.rb

@@ -13,28 +13,27 @@ module RuboCop
       #
       #   # good
       #   something if b && a
-      class NestedModifier < Cop
+      class NestedModifier < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Avoid using nested modifiers.'
 
         def on_while(node)
           check(node)
         end
+        alias on_until on_while
+        alias on_if on_while
 
-        def on_until(node)
-          check(node)
-        end
-
-        def on_if(node)
-          check(node)
-        end
+        private
 
         def check(node)
           return if part_of_ignored_node?(node)
           return unless modifier?(node) && modifier?(node.parent)
 
-          add_offense(node, location: :keyword)
+          add_offense(node.loc.keyword) do |corrector|
+            autocorrect(corrector, node)
+          end
           ignore_node(node)
         end
 
@@ -42,15 +41,13 @@ module RuboCop
           node&.basic_conditional? && node&.modifier_form?
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           return unless node.if_type? && node.parent.if_type?
 
           range = range_between(node.loc.keyword.begin_pos,
                                 node.parent.condition.source_range.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(range, new_expression(node))
-          end
+          corrector.replace(range, new_expression(node))
         end
 
         def new_expression(inner_node)

data/lib/rubocop/cop/style/nested_parenthesized_calls.rb

@@ -12,9 +12,10 @@ module RuboCop
       #
       #   # bad
       #   method1(method2 arg)
-      class NestedParenthesizedCalls < Cop
+      class NestedParenthesizedCalls < Base
         include RangeHelp
         include AllowedMethods
+        extend AutoCorrector
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
@@ -24,29 +25,30 @@ module RuboCop
           node.each_child_node(:send, :csend) do |nested|
             next if allowed_omission?(nested)
 
-            add_offense(nested,
-                        location: nested.source_range,
-                        message: format(MSG, source: nested.source))
+            message = format(MSG, source: nested.source)
+            add_offense(nested.source_range, message: message) do |corrector|
+              autocorrect(corrector, nested)
+            end
           end
         end
         alias on_csend on_send
 
-        def autocorrect(nested)
+        private
+
+        def autocorrect(corrector, nested)
           first_arg = nested.first_argument.source_range
           last_arg = nested.last_argument.source_range
 
           leading_space =
             range_with_surrounding_space(range: first_arg.begin,
-                                         side: :left)
+                                         side: :left,
+                                         whitespace: true,
+                                         continuations: true)
 
-          lambda do |corrector|
-            corrector.replace(leading_space, '(')
-            corrector.insert_after(last_arg, ')')
-          end
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(last_arg, ')')
         end
 
-        private
-
         def allowed_omission?(send_node)
           !send_node.arguments? || send_node.parenthesized? ||
             send_node.setter_method? || send_node.operator_method? ||

data/lib/rubocop/cop/style/nested_ternary_operator.rb

@@ -15,7 +15,9 @@ module RuboCop
       #   else
       #     a2
       #   end
-      class NestedTernaryOperator < Cop
+      class NestedTernaryOperator < Base
+        extend AutoCorrector
+
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
               'constructs instead.'
 
@@ -23,21 +25,17 @@ module RuboCop
           return unless node.ternary?
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
-            add_offense(nested_ternary)
-          end
-        end
-
-        def autocorrect(node)
-          if_node = if_node(node)
-
-          lambda do |corrector|
-            corrector.replace(if_node, <<~RUBY.chop)
-              if #{if_node.condition.source}
-                #{remove_parentheses(if_node.if_branch.source)}
-              else
-                #{if_node.else_branch.source}
-              end
-            RUBY
+            add_offense(nested_ternary) do |corrector|
+              if_node = if_node(nested_ternary)
+
+              corrector.replace(if_node, <<~RUBY.chop)
+                if #{if_node.condition.source}
+                  #{remove_parentheses(if_node.if_branch.source)}
+                else
+                  #{if_node.else_branch.source}
+                end
+              RUBY
+            end
           end
         end
 

data/lib/rubocop/cop/style/next.rb

@@ -46,10 +46,11 @@ module RuboCop
       #     next unless a == 1
       #     puts a
       #   end
-      class Next < Cop
+      class Next < Base
         include ConfigurableEnforcedStyle
         include MinBodyLength
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `next` to skip iteration.'
         EXIT_TYPES = %i[break return].freeze
@@ -58,7 +59,7 @@ module RuboCop
           [Style::SafeNavigation]
         end
 
-        def investigate(_processed_source)
+        def on_new_investigation
           # When correcting nested offenses, we need to keep track of how much
           # we have adjusted the indentation of each line
           @reindented_lines = Hash.new(0)
@@ -77,16 +78,6 @@ module RuboCop
         alias on_until on_while
         alias on_for on_while
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.modifier_form?
-              autocorrect_modifier(corrector, node)
-            else
-              autocorrect_block(corrector, node)
-            end
-          end
-        end
-
         private
 
         def check(node)
@@ -94,8 +85,13 @@ module RuboCop
 
           offending_node = offense_node(node.body)
 
-          add_offense(offending_node,
-                      location: offense_location(offending_node))
+          add_offense(offense_location(offending_node)) do |corrector|
+            if offending_node.modifier_form?
+              autocorrect_modifier(corrector, offending_node)
+            else
+              autocorrect_block(corrector, offending_node)
+            end
+          end
         end
 
         def ends_with_condition?(body)

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -28,28 +28,30 @@ module RuboCop
       #   if x == nil
       #   end
       #
-      class NilComparison < Cop
+      class NilComparison < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         PREDICATE_MSG = 'Prefer the use of the `nil?` predicate.'
         EXPLICIT_MSG = 'Prefer the use of the `==` comparison.'
 
+        RESTRICT_ON_SEND = %i[== === nil?].freeze
+
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
 
         def on_send(node)
           style_check?(node) do
-            add_offense(node, location: :selector)
-          end
-        end
+            add_offense(node.loc.selector) do |corrector|
+              new_code = if prefer_comparison?
+                           node.source.sub('.nil?', ' == nil')
+                         else
+                           node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
+                         end
 
-        def autocorrect(node)
-          new_code = if prefer_comparison?
-                       node.source.sub('.nil?', ' == nil')
-                     else
-                       node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
-                     end
-          ->(corrector) { corrector.replace(node, new_code) }
+              corrector.replace(node, new_code)
+            end
+          end
         end
 
         private

data/lib/rubocop/cop/style/non_nil_check.rb

@@ -38,7 +38,11 @@ module RuboCop
       #   if !x.nil?
       #   end
       #
-      class NonNilCheck < Cop
+      class NonNilCheck < Base
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[!= nil? !].freeze
+
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
@@ -46,12 +50,11 @@ module RuboCop
 
         def on_send(node)
           return if ignored_node?(node)
+          return unless (offense_node = find_offense_node(node))
 
-          if not_equal_to_nil?(node)
-            add_offense(node, location: :selector)
-          elsif include_semantic_changes? &&
-                (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            add_offense(node)
+          message = message(node)
+          add_offense(offense_node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
@@ -68,19 +71,28 @@ module RuboCop
         end
         alias on_defs on_def
 
-        def autocorrect(node)
+        private
+
+        def find_offense_node(node)
+          if not_equal_to_nil?(node)
+            node.loc.selector
+          elsif include_semantic_changes? &&
+                (not_and_nil_check?(node) || unless_and_nil_check?(node))
+            node
+          end
+        end
+
+        def autocorrect(corrector, node)
           case node.method_name
           when :!=
-            autocorrect_comparison(node)
+            autocorrect_comparison(corrector, node)
           when :!
-            autocorrect_non_nil(node, node.receiver)
+            autocorrect_non_nil(corrector, node, node.receiver)
           when :nil?
-            autocorrect_unless_nil(node, node.receiver)
+            autocorrect_unless_nil(corrector, node, node.receiver)
           end
         end
 
-        private
-
         def unless_and_nil_check?(send_node)
           parent = send_node.parent
 
@@ -100,7 +112,7 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        def autocorrect_comparison(node)
+        def autocorrect_comparison(corrector, node)
           expr = node.source
 
           new_code = if include_semantic_changes?
@@ -111,24 +123,20 @@ module RuboCop
 
           return if expr == new_code
 
-          ->(corrector) { corrector.replace(node, new_code) }
+          corrector.replace(node, new_code)
         end
 
-        def autocorrect_non_nil(node, inner_node)
-          lambda do |corrector|
-            if inner_node.receiver
-              corrector.replace(node, inner_node.receiver.source)
-            else
-              corrector.replace(node, 'self')
-            end
+        def autocorrect_non_nil(corrector, node, inner_node)
+          if inner_node.receiver
+            corrector.replace(node, inner_node.receiver.source)
+          else
+            corrector.replace(node, 'self')
           end
         end
 
-        def autocorrect_unless_nil(node, receiver)
-          lambda do |corrector|
-            corrector.replace(node.parent.loc.keyword, 'if')
-            corrector.replace(node, receiver.source)
-          end
+        def autocorrect_unless_nil(corrector, node, receiver)
+          corrector.replace(node.parent.loc.keyword, 'if')
+          corrector.replace(node, receiver.source)
         end
       end
     end

data/lib/rubocop/cop/style/not.rb

@@ -13,10 +13,12 @@ module RuboCop
       #   # good
       #   x = !something
       #
-      class Not < Cop
+      class Not < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `!` instead of `not`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         OPPOSITE_METHODS = {
           :== => :!=,
@@ -30,19 +32,16 @@ module RuboCop
         def on_send(node)
           return unless node.prefix_not?
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          range = range_with_surrounding_space(range: node.loc.selector,
-                                               side: :right)
+          add_offense(node.loc.selector) do |corrector|
+            range = range_with_surrounding_space(range: node.loc.selector, side: :right)
 
-          if opposite_method?(node.receiver)
-            correct_opposite_method(range, node.receiver)
-          elsif requires_parens?(node.receiver)
-            correct_with_parens(range, node)
-          else
-            correct_without_parens(range)
+            if opposite_method?(node.receiver)
+              correct_opposite_method(corrector, range, node.receiver)
+            elsif requires_parens?(node.receiver)
+              correct_with_parens(corrector, range, node)
+            else
+              correct_without_parens(corrector, range)
+            end
           end
         end
 
@@ -58,23 +57,18 @@ module RuboCop
             child.if_type? && child.ternary?
         end
 
-        def correct_opposite_method(range, child)
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(child.loc.selector,
-                              OPPOSITE_METHODS[child.method_name].to_s)
-          end
+        def correct_opposite_method(corrector, range, child)
+          corrector.remove(range)
+          corrector.replace(child.loc.selector, OPPOSITE_METHODS[child.method_name].to_s)
         end
 
-        def correct_with_parens(range, node)
-          lambda do |corrector|
-            corrector.replace(range, '!(')
-            corrector.insert_after(node, ')')
-          end
+        def correct_with_parens(corrector, range, node)
+          corrector.replace(range, '!(')
+          corrector.insert_after(node, ')')
         end
 
-        def correct_without_parens(range)
-          ->(corrector) { corrector.replace(range, '!') }
+        def correct_without_parens(corrector, range)
+          corrector.replace(range, '!')
         end
       end
     end