rubocop 1.92.0 → 1.92.1

data/lib/rubocop/cop/layout/line_length.rb

@@ -85,7 +85,7 @@ module RuboCop
         /xi.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses]
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
         end
 
         def on_block(node)
@@ -122,6 +122,7 @@ module RuboCop
         def on_new_investigation
           @breakable_range_by_line_index = {}
           @breakable_string_delimiters = {}
+          @breakable_strings = {}
           @endless_methods_by_line = {}
           @heredocs = nil
 
@@ -207,6 +208,7 @@ module RuboCop
         def check_for_breakable_node(node)
           breakable_node = extract_breakable_node(node, max)
           return if breakable_node.nil?
+          return if compact_nested_array_break?(node, breakable_node)
 
           line_index = breakable_node.first_line - 1
           range = breakable_node.source_range
@@ -217,6 +219,20 @@ module RuboCop
           breakable_range_by_line_index[line_index] = range
         end
 
+        def compact_nested_array_break?(node, breakable_node)
+          return false if !node.array_type? || !node.square_brackets?
+          return false unless breakable_node.equal?(node.children.first)
+          return false unless breakable_node.source.start_with?('[')
+
+          compact_array_brackets_enforced?
+        end
+
+        def compact_array_brackets_enforced?
+          return false unless config.cop_enabled?('Layout/SpaceInsideArrayLiteralBrackets')
+
+          config.for_cop('Layout/SpaceInsideArrayLiteralBrackets')['EnforcedStyle'] == 'compact'
+        end
+
         def check_for_breakable_semicolons(processed_source)
           tokens = processed_source.tokens.select { |t| t.type == :tSEMI }
           tokens.reverse_each do |token|
@@ -238,6 +254,7 @@ module RuboCop
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
         end
 
+        # rubocop:disable-next Metrics/AbcSize
         def check_for_breakable_str(node)
           line_index = node.loc.line - 1
           return if breakable_range_by_line_index[line_index]
@@ -248,6 +265,7 @@ module RuboCop
 
           breakable_range_by_line_index[line_index] = range_between(pos, pos + 1)
           breakable_string_delimiters[line_index] = delimiter
+          breakable_strings[line_index] = node
         end
 
         def check_for_breakable_dstr(node) # rubocop:disable Metrics/AbcSize
@@ -301,7 +319,32 @@ module RuboCop
           return unless (pos = breakable_string_range(node))
 
           content_begin_pos = node.loc?(:begin) ? node.loc.begin.end_pos : source_range.begin_pos
-          pos.end_pos if pos.end_pos > content_begin_pos
+          if blank_left_part?(node, content_begin_pos, pos)
+            pos = breakable_string_range_at_limit(source_range)
+          end
+          pos.end_pos if pos && leaves_two_parts?(node, content_begin_pos, pos)
+        end
+
+        def leaves_two_parts?(node, content_begin_pos, pos)
+          pos.end_pos > content_begin_pos && !blank_rest?(node, pos.end_pos)
+        end
+
+        def blank_left_part?(node, content_begin_pos, pos)
+          return false unless pos.end_pos > content_begin_pos
+          return false unless starts_after_quote?(node)
+
+          blank_between?(content_begin_pos, pos.end_pos)
+        end
+
+        def starts_after_quote?(node)
+          return true if node.loc?(:begin)
+
+          quote = node.parent&.loc&.begin if node.parent&.dstr_type?
+          quote ? quote.end_pos == node.source_range.begin_pos : false
+        end
+
+        def blank_between?(begin_pos, end_pos)
+          range_between(begin_pos, end_pos).source.strip.empty?
         end
 
         # Locate where to break a string that is too long, ensuring that escape characters
@@ -325,11 +368,17 @@ module RuboCop
 
         def breakable_space_position(node, substr)
           limit = string_content_length(node) - 1
-          space_pos = substr.rindex(/\s/)
-          space_pos = substr[0, limit].rindex(/\s/) if space_pos && space_pos + 1 > limit
+          space_pos = space_before_word(node, substr.length - 1)
+          space_pos = space_before_word(node, limit - 1) if space_pos && space_pos + 1 > limit
           space_pos
         end
 
+        def space_before_word(node, max_pos)
+          return if max_pos.negative?
+
+          node.source.rindex(/\s(?=\S)/, max_pos)
+        end
+
         def escape_sequence_start(text)
           text.match(ESCAPE_SEQUENCE_TAIL)&.begin(1)
         end
@@ -339,10 +388,25 @@ module RuboCop
           return if adjustment.abs > source_range.size
 
           cut = source_range.adjust(end_pos: adjustment)
+          cut = cut.resize(size_before_whitespace_run(source_range.source, cut.size))
           escape_pos = escape_sequence_start(cut.source)
+
           escape_pos ? source_range.resize(escape_pos) : cut
         end
 
+        def size_before_whitespace_run(text, size)
+          return size if size.zero?
+          return size unless text[size]&.match?(/\s/)
+
+          text.rindex(/\S/, size - 1) || size
+        end
+
+        def blank_rest?(node, break_pos)
+          offset = break_pos - node.source_range.begin_pos
+
+          node.source[offset...string_content_length(node)].strip.empty?
+        end
+
         def string_content_length(node)
           content_end = node.loc?(:end) ? node.loc.end.begin_pos : node.source_range.end_pos
 
@@ -360,7 +424,9 @@ module RuboCop
         def opens_string?(begin_node)
           quote = begin_node.parent.loc.begin
 
-          quote && quote.end_pos == begin_node.source_range.begin_pos
+          return false unless quote
+
+          blank_between?(quote.end_pos, begin_node.source_range.begin_pos)
         end
 
         def breakable_range_by_line_index
@@ -375,6 +441,10 @@ module RuboCop
           @breakable_string_delimiters ||= {}
         end
 
+        def breakable_strings
+          @breakable_strings ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -431,10 +501,38 @@ module RuboCop
                           "\n"
                         end
 
-            corrector.insert_before(breakable_range, insertion) unless breakable_range.nil?
+            break_ranges(line_index).each do |range|
+              corrector.insert_before(range, insertion)
+            end
           end
         end
 
+        def break_ranges(line_index)
+          return [] if breakable_range.nil?
+          return [breakable_range] unless (node = breakable_strings[line_index])&.loc?(:end)
+
+          string_break_ranges(node, breakable_string_delimiters[line_index])
+        end
+
+        def string_break_ranges(node, delimiter)
+          ranges = [breakable_range]
+          pos = breakable_range.begin_pos
+
+          while (pos = next_string_break_position(node, pos, delimiter))
+            ranges << range_between(pos, pos + 1)
+          end
+
+          ranges
+        end
+
+        def next_string_break_position(node, pos, delimiter)
+          rest = parse("#{delimiter}#{node.source_range.with(begin_pos: pos).source}").ast
+          return unless rest&.str_type?
+          return unless (rest_pos = breakable_string_position(rest))
+
+          pos + rest_pos - delimiter.length
+        end
+
         def excess_range(uri_range, line, line_index)
           excessive_position = if uri_range && uri_range.begin < max
                                  uri_range.end

data/lib/rubocop/cop/layout/multiline_hash_brace_layout.rb

@@ -106,11 +106,13 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
                                    'line as the last hash element.'
 
-        # Moving the closing brace while `Style/HashAsLastArrayItem` or
-        # `Style/RedundantDoubleSplatHashBraces` removes the braces in the same pass leaves
-        # the brace behind.
+        # Moving the closing brace after a method call value while
+        # `Layout/MultilineMethodCallBraceLayout` moves that call's closing parenthesis
+        # before a comment in the same pass places the brace after the comment.
+        # Moving it while `Style/HashAsLastArrayItem` or `Style/RedundantDoubleSplatHashBraces`
+        # removes the braces in the same pass leaves the brace behind.
         def self.autocorrect_incompatible_with
-          [Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
+          [Layout::MultilineMethodCallBraceLayout, Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
         end
 
         def on_hash(node)

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -102,7 +102,7 @@ module RuboCop
         def autocorrect(corrector, node)
           if @send_node.block_node
             correct_selector_only(corrector, node)
-            correct_block(corrector, @send_node.block_node)
+            correct_block(corrector, @send_node.block_node, node.first_line)
           else
             AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
           end
@@ -114,10 +114,21 @@ module RuboCop
           AlignmentCorrector.correct(corrector, processed_source, selector_range, @column_delta)
         end
 
-        def correct_block(corrector, block_node)
-          AlignmentCorrector.correct(corrector, processed_source, block_node.body, @column_delta)
-          end_range = range_by_whole_lines(block_node.loc.end, include_final_newline: false)
-          AlignmentCorrector.correct(corrector, processed_source, end_range, @column_delta)
+        def correct_block(corrector, block_node, selector_line)
+          lines_to_shift = block_lines(block_node) - [selector_line]
+
+          lines_to_shift.each do |line|
+            line_range = processed_source.buffer.line_range(line)
+
+            AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
+          end
+        end
+
+        def block_lines(block_node)
+          body = block_node.body
+          lines = body ? (body.first_line..body.last_line).to_a : []
+
+          (lines << block_node.loc.end.line).uniq
         end
 
         def relevant_node?(send_node)

data/lib/rubocop/cop/layout/single_line_block_chain.rb

@@ -25,10 +25,10 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
-        # `Style/FloatDivision` and `Style/NilComparison` rewrite a method chained to the block
-        # in the same pass, which must not start a line of its own.
+        # These cops rewrite a method chained to the block in the same pass,
+        # which must not start a line of its own.
         def self.autocorrect_incompatible_with
-          [Style::FloatDivision, Style::MapToHash, Style::NilComparison]
+          [Style::FloatDivision, Style::MapToHash, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)

data/lib/rubocop/cop/layout/space_inside_reference_brackets.rb

@@ -108,14 +108,9 @@ module RuboCop
         end
 
         def left_ref_bracket(node, tokens)
-          current_token = tokens.reverse.find(&:left_ref_bracket?)
-          previous_token = previous_token(current_token)
+          bracket_pos = node.loc.selector.begin_pos
 
-          if node.method?(:[]=) || (previous_token && !previous_token.right_bracket?)
-            tokens.find(&:left_ref_bracket?)
-          else
-            current_token
-          end
+          tokens.find { |token| token.left_ref_bracket? && token.begin_pos == bracket_pos }
         end
 
         def closing_bracket(tokens, opening_bracket)
@@ -129,11 +124,6 @@ module RuboCop
           end
         end
 
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
         def empty_config
           cop_config['EnforcedStyleForEmptyBrackets']
         end

data/lib/rubocop/cop/lint/ambiguous_regexp_literal.rb

@@ -55,7 +55,8 @@ module RuboCop
           return node if first_argument_is_regexp?(node) || !node.parent
 
           if (node.parent.send_type? && node.receiver) ||
-             method_chain_to_regexp_receiver?(node, regexp_receiver)
+             method_chain_to_regexp_receiver?(node, regexp_receiver) ||
+             part_of_hash_argument?(node)
             node = find_offense_node(node.parent, regexp_receiver)
           end
 
@@ -72,6 +73,10 @@ module RuboCop
 
           parent.parent && parent_receiver.receiver == regexp_receiver
         end
+
+        def part_of_hash_argument?(node)
+          node.pair_type? || node.parent.pair_type? || (node.hash_type? && !node.braces?)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/heredoc_method_call_position.rb

@@ -34,6 +34,10 @@ module RuboCop
 
         MSG = 'Put a method call with a HEREDOC receiver on the same line as the HEREDOC opening.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           heredoc = heredoc_node_descendent_receiver(node)
           return unless heredoc

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -140,6 +140,8 @@ module RuboCop
               corrected_method: correct_sym_method(to_method)
             )
             add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
               remove_parentheses(corrector, node) if node.parenthesized?
 
               corrector.replace(sym_node, correct_sym_method(to_method))

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -60,7 +60,7 @@ module RuboCop
 
             rest_operands = grouped_operands[begin_of_rest_operands..]
             rest_operands.each do |operand|
-              next if already_appropriate_call?(operand, dot_op)
+              next unless correction_needed?(operand, dot_op, grouped_operands)
 
               register_offense(operand, dot_op)
             end
@@ -100,12 +100,58 @@ module RuboCop
           end
         end
 
+        def correction_needed?(operand, dot_op, grouped_operands)
+          return false if already_appropriate_call?(operand, dot_op)
+
+          dot_op == '&.' || receiver_guaranteed?(operand, grouped_operands)
+        end
+
         def already_appropriate_call?(operand, dot_op)
           return true if operand.safe_navigation? && dot_op == '&.'
 
           (operand.dot? || operand.operator_method?) && dot_op == '.'
         end
 
+        def receiver_guaranteed?(operand, grouped_operands)
+          grouped_operands.take_while { |guard| !guard.equal?(operand) }.any? do |guard|
+            guaranteed_by?(guard, operand)
+          end
+        end
+
+        def guaranteed_by?(guard, operand)
+          return false unless (path = logical_path(guard, operand))
+
+          truthiness = path.last.first.and_type? ? :truthy : :falsey
+          path[0...-1].reverse_each do |node, child|
+            return false unless (truthiness = child_truthiness(node, child, truthiness))
+          end
+
+          !guard.csend_type? || truthiness == :truthy
+        end
+
+        def logical_path(guard, operand)
+          path = []
+          child = guard
+
+          guard.each_ancestor do |node|
+            unless node.begin_type?
+              return nil unless node.operator_keyword?
+
+              path << [node, child]
+            end
+            return path if operand.each_ancestor.any? { |ancestor| ancestor.equal?(node) }
+
+            child = node
+          end
+        end
+
+        def child_truthiness(node, child, truthiness)
+          deciding = node.and_type? ? :truthy : :falsey
+          return truthiness == deciding ? deciding : :unknown if node.lhs.equal?(child)
+
+          deciding if truthiness == deciding
+        end
+
         def register_offense(operand, dot_operator)
           offense_range = operand.operator_method? ? operand : operand.loc.dot
           message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -185,6 +185,7 @@ module RuboCop
             ignore_node(key)
 
             next if requires_quotes?(key)
+            next if key.parent.value_omission?
             next if properly_quoted?(key.source, %("#{key.value}"))
 
             correction = %("#{key.value}")

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -35,15 +35,13 @@ module RuboCop
         ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
         def on_def(node)
-          return unless node.body
+          return if !node.body || node.void_context?
 
           last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(node.body)
           receiver, = *last_expr
-          variable_name, = *receiver
-          return unless tracker.contain_local_object?(variable_name)
+          return unless contain_local_object?(node.body, receiver)
 
           loc_name = receiver.loc.name
 
@@ -66,6 +64,11 @@ module RuboCop
           expression.is_a?(Array) ? expression.last : expression
         end
 
+        def contain_local_object?(body, receiver)
+          variable_name, = *receiver
+          MethodVariableTracker.new(body).contain_local_object?(variable_name)
+        end
+
         # This class tracks variable assignments in a method body
         # and if a variable contains object passed as argument at the end of
         # the method.

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -76,11 +76,7 @@ module RuboCop
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
 
-        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
+        elements = elements.drop(1) unless first_element_movable?(node)
 
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
@@ -93,7 +89,12 @@ module RuboCop
       end
 
       # @api private
-      def first_argument_is_heredoc?(node)
+      # If a method call or definition is not parenthesized, the first element cannot be moved,
+      # because it can result in changed behavior or a syntax error.
+      def first_element_movable?(node)
+        return !node.arguments.loc.begin.nil? if node.any_def_type?
+        return true if !node.call_type? || node.parenthesized?
+
         node.first_argument.respond_to?(:heredoc?) && node.first_argument.heredoc?
       end
 

data/lib/rubocop/cop/mixin/check_single_line_suitability.rb

@@ -5,6 +5,8 @@ module RuboCop
     # Checks for code on multiple lines that could be rewritten on a single line
     # without changing semantics or exceeding the `Max` parameter of `Layout/LineLength`.
     module CheckSingleLineSuitability
+      include LineLengthHelp
+
       def suitable_as_single_line?(node)
         !too_long?(node) &&
           !comment_within?(node) &&
@@ -21,7 +23,7 @@ module RuboCop
         return false unless max_line_length
 
         lines = processed_source.lines[(line_range.begin - 1)...line_range.end]
-        to_single_line(lines.join("\n")).length > max_line_length
+        line_length(to_single_line(lines.join("\n"))) > max_line_length
       end
 
       def to_single_line(source)

data/lib/rubocop/cop/mixin/endless_method_body_help.rb

@@ -45,12 +45,44 @@ module RuboCop
 
       def command_disallowed_in_endless_body?(body)
         return true if body.assignment? && command_call?(assigned_value(body))
+        return true if body_disallowed_in_argument?(body)
+        return true if negated_command_call?(body)
 
         body.each_node(:any_block).any? do |block|
           block.keywords? && command_call?(block.send_node)
         end
       end
 
+      def body_disallowed_in_argument?(body)
+        command_body_in_argument?(body) || do_end_block_body_in_command_argument?(body)
+      end
+
+      # `private def foo = bar baz` parses only on Ruby 4.0+, and only as the sole argument.
+      def command_body_in_argument?(body)
+        return false unless command_call?(body)
+
+        call = argument_receiving_call(body.parent)
+        return false if call.nil?
+
+        target_ruby_version < 4.0 || !call.arguments.one?
+      end
+
+      def argument_receiving_call(def_node)
+        call = def_node.parent
+        return unless call&.call_type?
+
+        call if call.arguments.any? { |argument| argument.equal?(def_node) }
+      end
+
+      def do_end_block_body_in_command_argument?(body)
+        call = argument_receiving_call(body.parent)
+        return false if call.nil? || call.parenthesized?
+
+        body.each_node(:any_block).any? do |block|
+          block.keywords? && !block.send_node.lambda_literal?
+        end
+      end
+
       def assigned_value(node)
         while node.assignment? || node.rescue_type?
           node = node.rescue_type? ? node.body : node.children.last
@@ -64,6 +96,10 @@ module RuboCop
 
         node.arguments? && !node.parenthesized? && !node.operator_method? && !node.setter_method?
       end
+
+      def negated_command_call?(node)
+        node.send_type? && node.prefix_bang? && command_call?(node.receiver)
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -60,8 +60,9 @@ module RuboCop
 
         def deltas(first_pair, current_pair)
           key_delta = key_delta(first_pair, current_pair)
-          separator_delta = separator_delta(first_pair, current_pair, key_delta)
-          value_delta = value_delta(first_pair, current_pair) - key_delta - separator_delta
+          shift = separator_shift(current_pair, key_delta)
+          separator_delta = separator_delta(first_pair, current_pair, shift)
+          value_delta = value_delta(first_pair, current_pair) - shift - separator_delta
 
           { key: key_delta, separator: separator_delta, value: value_delta }
         end
@@ -78,9 +79,13 @@ module RuboCop
           pair.value && pair.key.last_line != pair.value.first_line
         end
 
-        def separator_delta(first_pair, current_pair, key_delta)
+        def separator_shift(current_pair, key_delta)
+          current_pair.key.multiline? ? 0 : key_delta
+        end
+
+        def separator_delta(first_pair, current_pair, shift)
           if current_pair.hash_rocket?
-            hash_rocket_delta(first_pair, current_pair) - key_delta
+            hash_rocket_delta(first_pair, current_pair) - shift
           else
             0
           end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -98,7 +98,7 @@ module RuboCop
 
       # rubocop:disable-next Metrics/AbcSize
       def if_body_source(if_body)
-        if if_body.call_type? && !if_body.method?(:[]=) && omitted_value_in_last_hash_arg?(if_body)
+        if unparenthesized_call_with_omitted_value?(if_body)
           "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
         elsif (value = wrapped_value(if_body))
           prefix = if_body.source_range.begin.join(value.source_range.begin).source
@@ -110,7 +110,8 @@ module RuboCop
         end
       end
 
-      def omitted_value_in_last_hash_arg?(if_body)
+      def unparenthesized_call_with_omitted_value?(if_body)
+        return false if !if_body.call_type? || if_body.method?(:[]=) || if_body.parenthesized?
         return false unless (last_argument = if_body.last_argument)
 
         last_argument.hash_type? && last_argument.pairs.last&.value_omission?

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -63,9 +63,10 @@ module RuboCop
         (send nil? VISIBILITY_SCOPES def)
       PATTERN
 
+      # A modifier applies to every symbol it is given, not only to a sole argument.
       # @!method visibility_inline_on_method_name?(node, method_name:)
       def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
-        (send nil? VISIBILITY_SCOPES (sym %method_name))
+        (send nil? VISIBILITY_SCOPES <(sym %method_name) ...>)
       PATTERN
     end
   end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -128,7 +128,7 @@ module RuboCop
             if child_node.lvar_type?
               parent_node = child_node.parent
               if parent_node.respond_to?(:value_omission?) && parent_node.value_omission?
-                corrector.insert_after(parent_node.loc.operator, " #{preferred_name}")
+                corrector.replace(parent_node.loc.operator, ": #{preferred_name}")
               else
                 corrector.replace(child_node, preferred_name)
               end