rubocop 1.92.0 → 1.92.2

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

@@ -74,7 +74,7 @@ module RuboCop
 
           arguments = [exception_node, message_node].compact.map(&:source).join(', ')
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{arguments})"
           else
             "#{node.method_name} #{arguments}"
@@ -86,31 +86,60 @@ module RuboCop
           return if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.receiver&.source || exception_node.source
+          exception_class = exception_class_node(exception_node).source
 
-          if node.parent && requires_parens?(node.parent)
+          if parenthesize?(node)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
             "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 
+        def exception_class_node(exception_node)
+          use_new_method?(exception_node) ? exception_node.receiver : exception_node
+        end
+
         def check_compact(node)
           if node.arguments.size > 1
             exception = node.first_argument
             return if exception.send_type? && exception.first_argument&.hash_type?
+            return if use_new_method?(exception) && exception.arguments?
 
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
-              replacement = correction_exploded_to_compact(node)
-
-              corrector.replace(node, replacement)
-              opposite_style_detected
+              correct_raise(node) { correct_to_compact(corrector, node) }
             end
           else
             correct_style_detected
           end
         end
 
+        def correct_to_compact(corrector, node)
+          if heredoc_message?(node)
+            correct_heredoc_exploded_to_compact(corrector, node)
+          else
+            corrector.replace(node, correction_exploded_to_compact(node))
+          end
+        end
+
+        def heredoc_message?(node)
+          node.parenthesized? && node.arguments.size == 2 && heredoc?(node.last_argument)
+        end
+
+        def heredoc?(node)
+          node.each_node(:any_str).any?(&:heredoc?)
+        end
+
+        def correct_heredoc_exploded_to_compact(corrector, node)
+          exception_node, message_node = *node.arguments
+          exception_class = exception_class_node(exception_node)
+          corrector.replace(range_between(exception_class, message_node), '.new(')
+          corrector.insert_after(message_node, ')')
+        end
+
+        def range_between(left_node, right_node)
+          left_node.source_range.end.join(right_node.source_range.begin)
+        end
+
         def check_exploded(node)
           return correct_style_detected unless node.arguments.one?
 
@@ -121,13 +150,43 @@ module RuboCop
           return if allowed_non_exploded_type?(first_arg)
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
-            replacement = correction_compact_to_exploded(node)
+            correct_raise(node) { correct_to_exploded(corrector, node) }
+          end
+        end
 
-            corrector.replace(node, replacement)
-            opposite_style_detected
+        def correct_to_exploded(corrector, node)
+          if heredoc_new_argument?(node)
+            correct_heredoc_compact_to_exploded(corrector, node)
+          else
+            corrector.replace(node, correction_compact_to_exploded(node))
           end
         end
 
+        def heredoc_new_argument?(node)
+          new_call = node.first_argument
+          return false unless new_call.arguments.one? && heredoc?(new_call.first_argument)
+
+          node.parenthesized? || !parenthesize?(node)
+        end
+
+        def correct_heredoc_compact_to_exploded(corrector, node)
+          new_call = node.first_argument
+          corrector.replace(range_between(new_call.receiver, new_call.first_argument), ', ')
+          corrector.remove(new_call.loc.end) if new_call.loc.end
+        end
+
+        def correct_raise(node)
+          opposite_style_detected
+          return if inside_corrected_raise?(node)
+
+          yield
+          ignore_node(node)
+        end
+
+        def inside_corrected_raise?(node)
+          node.each_ancestor(:send).any? { |ancestor| ignored_node?(ancestor) }
+        end
+
         def use_new_method?(first_arg)
           first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
         end
@@ -151,8 +210,18 @@ module RuboCop
           Array(cop_config['AllowedCompactTypes']).include?(type)
         end
 
+        def parenthesize?(node)
+          return true if node.parenthesized?
+
+          node.parent && requires_parens?(node.parent)
+        end
+
         def requires_parens?(parent)
-          parent.operator_keyword? || (parent.if_type? && parent.ternary?)
+          return true if parent.operator_keyword?
+          return true if parent.type?(:call, :super, :yield, :array, :pair)
+          return true if parent.any_def_type? && parent.endless?
+
+          parent.if_type? && parent.ternary?
         end
       end
     end

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

@@ -100,6 +100,7 @@ module RuboCop
           return unless key
           return if accumulator_used_in_expressions?(block_node, key, value)
           return if nested_match?(key) || nested_match?(value)
+          return if heredoc_in_inject_numblock?(block_node, key, value)
 
           register_offense(node, block_node, key, value)
         end
@@ -124,6 +125,12 @@ module RuboCop
           end
         end
 
+        def heredoc_in_inject_numblock?(block_node, key, value)
+          return false if !block_node.numblock_type? || block_node.method?(:each_with_object)
+
+          [key, value].any? { |node| node.each_node(:any_str).any?(&:heredoc?) }
+        end
+
         def accumulator_name(block_node)
           index = block_node.method?(:each_with_object) ? 1 : 0
           block_node.argument_list[index].name
@@ -136,42 +143,20 @@ module RuboCop
         def register_offense(send_node, block_node, key_expr, value_expr)
           message = format(MSG, method: send_node.method_name)
 
+          # Each part is replaced separately so that heredoc bodies between them are kept.
           add_offense(send_node.loc.selector, message: message) do |corrector|
-            corrector.replace(
-              replacement_range(send_node, block_node),
-              replacement(block_node, key_expr, value_expr)
-            )
-          end
-        end
+            corrector.replace(method_call_range(send_node), 'to_h')
 
-        def replacement(block_node, key_expr, value_expr)
-          key_source = adjusted_source(key_expr, block_node)
-          value_source = adjusted_source(value_expr, block_node)
-          body = "[#{key_source}, #{value_source}]"
-
-          if block_node.numblock_type?
-            block_node.braces? ? "to_h { #{body} }" : do_end_replacement(block_node, body)
-          else
-            named_block_replacement(block_node, body)
-          end
-        end
+            unless block_node.numblock_type?
+              corrector.replace(block_node.arguments, "|#{element_arg_source(block_node)}|")
+            end
 
-        def named_block_replacement(block_node, body)
-          arg = element_arg_source(block_node)
-          if block_node.braces?
-            "to_h { |#{arg}| #{body} }"
-          else
-            do_end_replacement(block_node, body, arg)
+            correct_body(corrector, block_node, key_expr, value_expr)
           end
         end
 
-        def do_end_replacement(block_node, body, arg = nil)
-          args = arg ? " |#{arg}|" : ''
-          "to_h do#{args}\n#{indent(block_node)}  #{body}\n#{indent(block_node)}end"
-        end
-
-        def replacement_range(send_node, block_node)
-          range_between(send_node.loc.selector.begin_pos, block_node.source_range.end_pos)
+        def method_call_range(send_node)
+          range_between(send_node.loc.selector.begin_pos, send_node.source_range.end_pos)
         end
 
         def element_arg_source(block_node)
@@ -182,6 +167,16 @@ module RuboCop
           end
         end
 
+        def correct_body(corrector, block_node, key_expr, value_expr)
+          key_source = adjusted_source(key_expr, block_node)
+          value_source = adjusted_source(value_expr, block_node)
+          body = block_node.body
+          assignment = body.begin_type? ? body.children.first : body
+
+          corrector.replace(assignment, "[#{key_source}, #{value_source}]")
+          corrector.remove(accumulator_range(body.children.last)) if body.begin_type?
+        end
+
         def adjusted_source(expr_node, block_node)
           source = element_source(expr_node)
           return source unless block_node.numblock_type?
@@ -191,10 +186,6 @@ module RuboCop
           source.gsub('_2', '_1')
         end
 
-        def indent(node)
-          ' ' * node.source_range.column
-        end
-
         def element_source(expr_node)
           if command_call?(expr_node) || expr_node.assignment? || expr_node.rescue_type?
             return "(#{expr_node.source})"
@@ -210,6 +201,13 @@ module RuboCop
 
           node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
         end
+
+        def accumulator_range(accumulator)
+          range = range_with_surrounding_space(accumulator.source_range, side: :left)
+          return range unless range.source_buffer.source[range.begin_pos - 1] == ';'
+
+          range_with_surrounding_space(range.adjust(begin_pos: -1), side: :left, newlines: false)
+        end
       end
     end
   end

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

@@ -67,6 +67,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `begin` block detected.'
+        SPACE_INSIDE_PARENS_STYLES = %w[space compact].freeze
 
         def self.autocorrect_incompatible_with
           [Style::BlockDelimiters]
@@ -132,7 +133,8 @@ module RuboCop
           empty_begin?(node) ||
             begin_block_has_multiline_statements?(node) ||
             contain_rescue_or_ensure?(node) ||
-            valid_context_using_only_begin?(node)
+            valid_context_using_only_begin?(node) ||
+            ternary_operand_requiring_begin?(node)
         end
 
         def register_offense(node)
@@ -191,7 +193,8 @@ module RuboCop
         def use_modifier_form_after_multiline_begin_block?(node)
           return false unless (parent = node.parent)
 
-          node.multiline? && parent.if_type? && parent.modifier_form?
+          node.multiline? && parent.if_type? && parent.modifier_form? &&
+            !parent.condition.equal?(node)
         end
 
         def correct_modifier_form_after_multiline_begin_block(corrector, node)
@@ -228,6 +231,12 @@ module RuboCop
             parent&.send_type? || parent&.operator_keyword?
         end
 
+        def ternary_operand_requiring_begin?(node)
+          return false unless node.parent&.if_type? && node.parent.ternary?
+
+          !node.children.one? || low_precedence_statement?(node.children.first)
+        end
+
         def valid_begin_assignment?(node)
           node.parent&.assignment? && (!node.children.one? || too_long_when_joined?(node))
         end
@@ -238,14 +247,28 @@ module RuboCop
           return false unless max && statement.single_line?
 
           length = statement.source.length
-          length += 2 if low_precedence_statement?(statement)
+          length += parentheses_width if low_precedence_statement?(statement)
+
           node.loc.column + length > max
         end
 
+        def parentheses_width
+          space_inside_parens? ? 4 : 2
+        end
+
+        def space_inside_parens?
+          return false unless config.cop_enabled?('Layout/SpaceInsideParens')
+
+          style = config.for_cop('Layout/SpaceInsideParens')['EnforcedStyle']
+
+          SPACE_INSIDE_PARENS_STYLES.include?(style)
+        end
+
         def inspect_branches(node)
           node.branches.each do |branch|
             next unless branch&.kwbegin_type?
             next if branch.rescue_node || branch.ensure_node
+            next if ternary_operand_requiring_begin?(branch)
 
             register_offense(branch)
           end

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

@@ -37,23 +37,18 @@ module RuboCop
         private
 
         def fix_exploded(node)
-          exploded?(node) do |command, message|
+          exploded?(node) do |exception, message|
             # `raise RuntimeError, nil` uses the class name as the message, so
             # rewriting it to `raise nil.to_s` (an empty message) would change it.
             next if message.nil_type?
 
             add_offense(node, message: MSG_1) do |corrector|
-              corrector.replace(node, replaced_exploded(node, command, message))
+              corrector.remove(exception.source_range.join(message.source_range.begin))
+              corrector.replace(message, message_source(message))
             end
           end
         end
 
-        def replaced_exploded(node, command, message)
-          arg = message_source(message)
-          arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
-          "#{command}#{arg}"
-        end
-
         def string_message?(message)
           message.any_str_type?
         end
@@ -63,11 +58,20 @@ module RuboCop
             next if message.nil_type?
 
             add_offense(node, message: MSG_2) do |corrector|
+              # Replacing the call would drop a heredoc body that sits inside its parentheses.
+              next if heredoc_body_inside?(new_call, message)
+
               corrector.replace(new_call, message_source(message))
             end
           end
         end
 
+        def heredoc_body_inside?(new_call, message)
+          message.each_node(:any_str).any? do |str|
+            str.heredoc? && str.loc.heredoc_end.end_pos < new_call.source_range.end_pos
+          end
+        end
+
         def message_source(message)
           if string_message?(message)
             message.source
@@ -90,7 +94,7 @@ module RuboCop
 
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
+          (send nil? {:raise :fail} $(const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
         # @!method compact?(node)

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

@@ -29,8 +29,7 @@ module RuboCop
                          operation_produces_immutable_object?(node.receiver))
 
           add_offense(node) do |corrector|
-            corrector.remove(node.loc.dot)
-            corrector.remove(node.loc.selector)
+            corrector.remove(node.loc.dot.join(node.loc.selector))
           end
         end
 

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

@@ -30,6 +30,10 @@ module RuboCop
 
         minimum_target_ruby_version 3.0
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodCallBraceLayout]
+        end
+
         # @!method redundant_unfreeze?(node)
         def_node_matcher :redundant_unfreeze?, <<~PATTERN
           {
@@ -41,9 +45,10 @@ module RuboCop
         def on_dstr(node)
           return if uninterpolated_string?(node) || uninterpolated_heredoc?(node)
           return unless redundant_unfreeze?(node.parent)
+          return if comment_outside_string?(node)
 
           add_offense(offense_range(node.parent)) do |corrector|
-            corrector.replace(node.parent, node.source)
+            remove_unfreeze(corrector, node.parent, node)
           end
         end
 
@@ -56,6 +61,24 @@ module RuboCop
             node.loc.selector
           end
         end
+
+        # Only the parts around the string are removed, so that an unfrozen string
+        # interpolated into it can be corrected in the same pass.
+        def remove_unfreeze(corrector, node, string)
+          corrector.remove(node.source_range.begin.join(string.source_range.begin))
+          corrector.remove(string.source_range.end.join(node.source_range.end))
+        end
+
+        def comment_outside_string?(node)
+          call_range = node.parent.source_range
+          string_range = node.source_range
+
+          processed_source.comments.any? do |comment|
+            range = comment.source_range
+
+            call_range.contains?(range) && !string_range.contains?(range)
+          end
+        end
       end
     end
   end

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

@@ -115,7 +115,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
-          return if node.parent&.mlhs_type?
+          return if multiple_assignment_target?(node)
           return if allowed_send_node?(node)
           return if it_method_in_block?(node)
 
@@ -154,6 +154,14 @@ module RuboCop
           end
         end
 
+        def multiple_assignment_target?(node)
+          return false unless (parent = node.parent)
+
+          parent = parent.parent if parent.splat_type?
+
+          parent.mlhs_type?
+        end
+
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
             @local_variables_scopes[node].include?(node.method_name) ||

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

@@ -23,14 +23,20 @@ module RuboCop
       #   foo = bar unless condition
       #
       class RedundantSelfAssignmentBranch < Base
+        include RescueNode
         extend AutoCorrector
 
         MSG = 'Remove the self-assignment branch.'
 
+        STATEMENT_BODY_TYPES = %i[
+          kwbegin def defs block numblock itblock class module sclass rescue ensure
+        ].freeze
+
         def on_lvasgn(node)
           expression = node.expression
 
           return unless use_if_and_else_branch?(expression)
+          return unless statement?(node)
 
           if_branch = expression.if_branch
           else_branch = expression.else_branch
@@ -51,6 +57,28 @@ module RuboCop
           !expression.ternary? || !expression.else?
         end
 
+        def statement?(node)
+          parent = node.parent
+          return true if parent.nil? || parent.type?(*STATEMENT_BODY_TYPES)
+          return parent.loc.begin.nil? if parent.begin_type?
+          return !rescue_modifier?(parent) if parent.resbody_type?
+
+          statement_branch?(node, parent)
+        end
+
+        def statement_branch?(node, parent)
+          case parent.type
+          when :if
+            !parent.ternary? && !node.equal?(parent.condition)
+          when :when, :in_pattern, :while, :until, :for
+            node.equal?(parent.body)
+          when :case, :case_match
+            node.equal?(parent.else_branch)
+          else
+            false
+          end
+        end
+
         def inconvertible_to_modifier?(if_branch, else_branch)
           multiple_statements?(if_branch) || multiple_statements?(else_branch) ||
             (else_branch.respond_to?(:elsif?) && else_branch.elsif?)

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

@@ -123,12 +123,29 @@ module RuboCop
         end
 
         def register_offense(node, sort_node, sorter, accessor)
+          return if code_after_accessor_kept_apart?(node)
+
           message = message(node, sorter, accessor)
           add_offense(offense_range(sort_node, node), message: message) do |corrector|
             autocorrect(corrector, node, sort_node, sorter, accessor)
           end
         end
 
+        def code_after_accessor_kept_apart?(node)
+          return false if with_logical_operator?(node)
+
+          source = before_accessor_source(node)
+          return false if !source.include?("\n") || source.strip.empty?
+
+          rest = code_after_accessor(node)
+
+          !rest.empty? && !rest.match?(/\A(#|&?\.|[)\]},])/)
+        end
+
+        def code_after_accessor(node)
+          processed_source.lines[node.last_line - 1][node.source_range.last_column..].strip
+        end
+
         def offense_range(sort_node, node)
           range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
@@ -146,12 +163,29 @@ module RuboCop
         end
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
-          # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
-          # Replace to avoid syntax errors when followed by a logical operator.
-          replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          remove_accessor(corrector, node)
+        end
+
+        def remove_accessor(corrector, node)
+          if removable_line_break_before_accessor?(node)
+            corrector.remove(node.receiver.source_range.end.join(node.source_range.end))
+          else
+            corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
+
+            replace_with_logical_operator(corrector, node) if with_logical_operator?(node)
+          end
+        end
+
+        def removable_line_break_before_accessor?(node)
+          source = before_accessor_source(node)
+
+          source.include?("\n") && source.strip.empty?
+        end
+
+        def before_accessor_source(node)
+          node.receiver.source_range.end.join((node.loc.dot || node.loc.selector).begin).source
         end
 
         def replace_with_logical_operator(corrector, node)

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

@@ -101,17 +101,19 @@ module RuboCop
         end
 
         def find_previous_older_sibling(node) # rubocop:disable Metrics
-          search_node(node).left_siblings.reverse.find do |sibling|
+          oldest = nil
+          search_node(node).left_siblings.reverse_each do |sibling|
             next unless sibling.is_a?(AST::Node)
 
-            sibling = sibling_node(sibling)
-            break unless sibling&.send_type? && sibling.method?(node.method_name)
-            break unless sibling.arguments? && !sibling.receiver
-            break unless in_same_section?(sibling, node)
-            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
+            required = sibling_node(sibling)
+            break unless required&.send_type? && required.method?(node.method_name)
+            break unless required.arguments? && !required.receiver
+            break unless in_same_section?(required, node)
+            break unless node.first_argument.str_type? && required.first_argument.str_type?
 
-            node.first_argument.value < sibling.first_argument.value
+            oldest = sibling if node.first_argument.value < required.first_argument.value
           end
+          oldest
         end
 
         def own_lines?(node)
@@ -124,9 +126,15 @@ module RuboCop
         def autocorrect(corrector, node, previous_older_sibling)
           range1 = range_with_comments_and_lines(previous_older_sibling)
           range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+          source = range2.source
+
+          unless source.end_with?("\n")
+            source += "\n"
+            range2 = range2.with(begin_pos: range2.begin_pos - 1)
+          end
 
           corrector.remove(range2)
-          corrector.insert_before(range1, range2.source)
+          corrector.insert_before(range1.begin, source)
         end
 
         def search_node(node)

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

@@ -56,16 +56,22 @@ module RuboCop
           add_offense(rescue_node) do |corrector|
             # The heredoc body would be left behind when the rescue body is moved.
             next if heredoc_end(node)
+            next if inside_corrected_rescue_body?(rescue_node)
 
             parenthesized = parenthesized?(rescue_node)
 
             correct_rescue_block(corrector, rescue_node, parenthesized)
             ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
+            ignore_node(rescue_node)
           end
         end
 
         private
 
+        def inside_corrected_rescue_body?(node)
+          node.each_ancestor(:resbody).any? { |resbody| ignored_node?(resbody.parent) }
+        end
+
         def parenthesized?(node)
           node.parent && parentheses?(node.parent)
         end

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

@@ -64,6 +64,10 @@ module RuboCop
           undef unless until when while yield
         ].freeze
 
+        def self.autocorrect_incompatible_with
+          [Layout::MultilineMethodArgumentLineBreaks]
+        end
+
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return if allow_send? && !node.method?(:public_send)