rubocop 0.88.0 → 0.91.1

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

@@ -18,7 +18,7 @@ module RuboCop
       #           baz)
       #   end
       #
-      class MultilineMethodSignature < Cop
+      class MultilineMethodSignature < Base
         MSG = 'Avoid multi-line method signatures.'
 
         def on_def(node)
@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def max_line_length
-          config.for_cop('Layout/LineLength')['Max'] || 80
+          config.for_cop('Layout/LineLength')['Max'] || 120
         end
       end
     end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       #
+      # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+      # multiline ternary operator expression, it cannot be auto-corrected.
+      #
       # @example
       #   # bad
       #   a = cond ?
@@ -22,18 +25,20 @@ module RuboCop
       #   else
       #     c
       #   end
-      class MultilineTernaryOperator < Cop
+      class MultilineTernaryOperator < Base
+        extend AutoCorrector
+
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'
 
         def on_if(node)
-          return unless node.ternary? && node.multiline?
+          return unless offense?(node)
 
-          add_offense(node)
-        end
+          add_offense(node) do |corrector|
+            # `return if ... else ... end` is syntax error. If `return` is used before
+            # multiline ternary operator expression, it cannot be auto-corrected.
+            next unless offense?(node) && !node.parent.return_type?
 
-        def autocorrect(node)
-          lambda do |corrector|
             corrector.replace(node, <<~RUBY.chop)
               if #{node.condition.source}
                 #{node.if_branch.source}
@@ -43,6 +48,12 @@ module RuboCop
             RUBY
           end
         end
+
+        private
+
+        def offense?(node)
+          node.ternary? && node.multiline?
+        end
       end
     end
   end

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

@@ -28,8 +28,9 @@ module RuboCop
       #                              arg2)
       #   end
       #
-      class MultilineWhenThen < Cop
+      class MultilineWhenThen < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Do not use `then` for multiline `when` statement.'
 
@@ -43,30 +44,28 @@ module RuboCop
           # Requires `then` for write `when` and its body on the same line.
           return if require_then?(node)
 
-          # With more than one statements after then, there's not offense
+          # For arrays and hashes there's no offense
           return if accept_node_type?(node.body)
 
-          add_offense(node, location: :begin)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          range = node.loc.begin
+          add_offense(range) do |corrector|
             corrector.remove(
-              range_with_surrounding_space(
-                range: node.loc.begin, side: :left, newlines: false
-              )
+              range_with_surrounding_space(range: range, side: :left, newlines: false)
             )
           end
         end
 
+        private
+
         def require_then?(when_node)
+          return true if when_node.conditions.count >= 2
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line
         end
 
         def accept_node_type?(node)
-          node&.begin_type? || node&.array_type? || node&.hash_type?
+          node&.array_type? || node&.hash_type?
         end
       end
     end

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
-      class MultipleComparison < Cop
+      class MultipleComparison < Base
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 

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

@@ -50,9 +50,10 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
-      class MutableConstant < Cop
+      class MutableConstant < Base
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
@@ -69,23 +70,6 @@ module RuboCop
           on_assignment(value)
         end
 
-        def autocorrect(node)
-          expr = node.source_range
-
-          lambda do |corrector|
-            splat_value = splat_value(node)
-            if splat_value
-              correct_splat_expansion(corrector, expr, splat_value)
-            elsif node.array_type? && !node.bracketed?
-              corrector.wrap(expr, '[', ']')
-            elsif requires_parentheses?(node)
-              corrector.wrap(expr, '(', ')')
-            end
-
-            corrector.insert_after(expr, '.freeze')
-          end
-        end
-
         private
 
         def on_assignment(value)
@@ -101,7 +85,9 @@ module RuboCop
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
         end
 
         def check(value)
@@ -112,7 +98,24 @@ module RuboCop
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          expr = node.source_range
+
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+          elsif node.array_type? && !node.bracketed?
+            corrector.wrap(expr, '[', ']')
+          elsif requires_parentheses?(node)
+            corrector.wrap(expr, '(', ')')
+          end
+
+          corrector.insert_after(expr, '.freeze')
         end
 
         def mutable_literal?(value)

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)