rubocop 1.91.0 → 1.92.1

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

@@ -56,6 +56,13 @@ module RuboCop
         ARG_MSG = 'Block argument expression is not on the same line as the block start.'
         PIPE_SIZE = '|'.length
 
+        # `Style/Lambda` moves the block arguments of `lambda` into `->(...)`, and
+        # `Style/ItBlockParameter` and `Style/HashEachMethods` remove some or all of them,
+        # in the same pass, while this cop moves them next to the block start.
+        def self.autocorrect_incompatible_with
+          [Style::HashEachMethods, Style::ItBlockParameter, Style::Lambda]
+        end
+
         def on_block(node)
           return if node.single_line?
 
@@ -155,7 +162,7 @@ module RuboCop
         end
 
         def include_trailing_comma?(args)
-          arg_count = args.each_descendant(:arg).to_a.size
+          arg_count = args.each_descendant.count(&:argument_type?)
           arg_count == 1 && args.source.include?(',')
         end
       end

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

@@ -106,6 +106,15 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
                                    'line as the last hash element.'
 
+        # 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
+          [Layout::MultilineMethodCallBraceLayout, Style::HashAsLastArrayItem, Style::RedundantDoubleSplatHashBraces]
+        end
+
         def on_hash(node)
           check_brace_layout(node)
         end

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

@@ -106,6 +106,12 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
                                    'the same line as the last argument.'
 
+        # Moving the closing parenthesis and removing it under `omit_parentheses` in the same pass
+        # leaves the moved parenthesis behind.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           check_brace_layout(node)
         end

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

@@ -73,14 +73,28 @@ module RuboCop
         end
 
         def find_pair_ancestor(node)
+          child = node
           node.each_ancestor do |ancestor|
             return ancestor if ancestor.pair_type?
             break if grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+            break if inside_body?(ancestor, child)
+
+            child = ancestor
           end
 
           nil
         end
 
+        # A block, `begin`, `if` or loop body is a separate set of statements, so
+        # a method chain in it is not the value of a hash pair the body is nested in.
+        # The send node of a block is still part of the value.
+        def inside_body?(ancestor, child)
+          return !child.equal?(ancestor.send_node) if ancestor.any_block_type?
+          return !ancestor.ternary? if ancestor.if_type?
+
+          ancestor.type?(:kwbegin, :while, :until, :for)
+        end
+
         def unwrap_block_node(node)
           node&.any_block_type? ? node.send_node : node
         end
@@ -88,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
@@ -100,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/multiline_method_definition_brace_layout.rb

@@ -118,6 +118,10 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
                                    'on the same line as the last parameter.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MultilineMethodSignature]
+        end
+
         def on_def(node)
           check_brace_layout(node.arguments)
         end

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

@@ -54,6 +54,11 @@ module RuboCop
 
         MSG = 'Redundant line break detected.'
 
+        def on_new_investigation
+          super
+          @offense_line_ranges = []
+        end
+
         def on_lvasgn(node)
           super unless end_with_percent_blank_string?(processed_source)
         end
@@ -77,12 +82,15 @@ module RuboCop
         end
 
         def check_assignment(node, _rhs)
-          return unless offense?(node)
+          return unless offense?(node) && !part_of_ignored_node?(node)
 
           register_offense(node)
         end
 
         def register_offense(node)
+          line_range = joined_line_range(node)
+          return if too_long_as_single_line?(line_range)
+
           # The exact single-line correction is verified to parse equivalently
           # before the offense is registered, so a join that would change how
           # the code parses is never reported or offered.
@@ -92,6 +100,19 @@ module RuboCop
             corrector.replace(node, to_single_line(node.source).strip)
           end
           ignore_node(node)
+          @offense_line_ranges.reject! { |range| line_range.cover?(range) }
+          @offense_line_ranges << line_range
+        end
+
+        # Offenses registered in the same pass that share a line with `node`
+        # get joined onto that line too, so the combined line has to fit.
+        def joined_line_range(node)
+          sharing_ranges = @offense_line_ranges.select do |range|
+            range.begin <= node.last_line && node.first_line <= range.end
+          end
+          lines = [node.first_line, node.last_line, *sharing_ranges.flat_map(&:minmax)]
+
+          lines.min..lines.max
         end
 
         def apply_reparse_correction(corrector, node)

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

@@ -22,6 +22,7 @@ module RuboCop
       #     puts 'error'
       #   end
       class RescueEnsureAlignment < Base
+        include Alignment
         include RangeHelp
         include EndKeywordAlignment
         extend AutoCorrector
@@ -74,9 +75,10 @@ module RuboCop
           # Some inline node is sitting before current node.
           return nil unless whitespace.source.strip.empty?
 
-          new_column = alignment_location.column
+          indentation = alignment_indentation(alignment_location)
+          return nil if indentation.nil?
 
-          corrector.replace(whitespace, ' ' * new_column)
+          corrector.replace(whitespace, indentation)
         end
 
         def format_message(alignment_node, alignment_loc, kw_loc)
@@ -91,6 +93,17 @@ module RuboCop
           )
         end
 
+        # A run of spaces sized to the target column would be turned back into tabs by
+        # `Layout/IndentationStyle`, generally landing on a different column, so under
+        # tabs the target line's own indentation is reused. There is nothing to reuse
+        # when the target does not start its line.
+        def alignment_indentation(location)
+          return ' ' * location.column unless using_tabs?
+          return unless begins_its_line?(location)
+
+          location.source_line[/\A\s*/]
+        end
+
         # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def alignment_source(node, starting_loc)
           ending_loc =

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

@@ -25,13 +25,17 @@ module RuboCop
 
         MSG = 'Put method call on a separate line if chained to a single line block.'
 
+        # 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::MapToHash]
+          [Style::FloatDivision, Style::MapToHash, Style::NilComparison, Style::RedundantSort]
         end
 
         def on_send(node)
           range = offending_range(node)
-          add_offense(range) { |corrector| corrector.insert_before(range, "\n") } if range
+          return if !range || heredoc_opened_before?(node.receiver, range)
+
+          add_offense(range) { |corrector| corrector.insert_before(range, "\n") }
         end
         alias on_csend on_send
 
@@ -63,6 +67,10 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
+
+        def heredoc_opened_before?(receiver, range)
+          receiver.each_node(:any_str).any? { |str| str.heredoc? && str.first_line == range.line }
+        end
       end
     end
   end

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

@@ -20,6 +20,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.prefix_bang? && whitespace_after_operator?(node)
+          return if unary_tilde?(node.receiver)
 
           add_offense(node) do |corrector|
             corrector.remove(
@@ -33,6 +34,10 @@ module RuboCop
         def whitespace_after_operator?(node)
           node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
+
+        def unary_tilde?(receiver)
+          receiver.send_type? && receiver.unary_operation? && receiver.method?(:~)
+        end
       end
     end
   end

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

@@ -6,7 +6,8 @@ module RuboCop
       # Checks the spacing inside and after block parameters pipes. Line breaks
       # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and
       # not by this cop. Spaces inside a lambda's parameter parentheses are left
-      # to `Layout/SpaceInsideParens` when that cop enforces a conflicting style.
+      # to `Layout/SpaceInsideParens` when that cop is enabled, so the examples
+      # below apply to a lambda only when it is not.
       #
       # @example EnforcedStyleInsidePipes: no_space (default)
       #   # bad
@@ -35,7 +36,7 @@ module RuboCop
 
           return unless node.arguments? && pipes?(arguments)
 
-          check_inside_pipes(arguments) unless conflicting_space_inside_parens_style?(arguments)
+          check_inside_pipes(arguments) unless checked_by_space_inside_parens?(arguments)
           check_after_closing_pipe(arguments) if node.body
           check_each_arg(arguments)
         end
@@ -54,14 +55,8 @@ module RuboCop
           'EnforcedStyleInsidePipes'
         end
 
-        def conflicting_space_inside_parens_style?(arguments)
-          return false unless arguments.loc.begin.source == '('
-
-          case config.for_enabled_cop('Layout/SpaceInsideParens')['EnforcedStyle']
-          when 'no_space' then style == :space
-          when 'space', 'compact' then style == :no_space
-          else false
-          end
+        def checked_by_space_inside_parens?(arguments)
+          arguments.loc.begin.source == '(' && config.cop_enabled?('Layout/SpaceInsideParens')
         end
 
         def check_inside_pipes(arguments)
@@ -153,7 +148,7 @@ module RuboCop
             if node
               corrector.insert_before(node, ' ')
             else
-              corrector.insert_after(target, ' ')
+              corrector.insert_after(range_between(space_begin_pos, space_begin_pos), ' ')
             end
           end
         end

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

@@ -209,6 +209,7 @@ module RuboCop
           end
 
           return unless space_after_missing?(range)
+          return if block_brace_with_no_space_style?(node, range)
 
           add_offense(range, message: format(MSG_AFTER, range: range.source)) do |corrector|
             corrector.insert_after(range, ' ')
@@ -233,6 +234,15 @@ module RuboCop
           !/[\s;,#\\)}\].]/.match?(char)
         end
 
+        def block_brace_with_no_space_style?(node, range)
+          return false unless (parent = node.parent)
+          return false unless parent.any_block_type? && parent.loc.begin&.begin_pos == range.end_pos
+
+          space_before_block_braces_config = config.for_cop('Layout/SpaceBeforeBlockBraces')
+          space_before_block_braces_config.fetch('Enabled', true) &&
+            space_before_block_braces_config['EnforcedStyle'] == 'no_space'
+        end
+
         def accepted_opening_delimiter?(range, char)
           return true unless char
 

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

@@ -49,8 +49,11 @@ module RuboCop
         MISSING_MSG = 'Space missing to the left of {.'
         DETECTED_MSG = 'Space detected to the left of {.'
 
+        # `Style/BlockDelimiters` decides whether to put a space before the `do`
+        # it writes by looking at the source before this cop removed the space,
+        # so the two corrections cannot be applied in the same pass.
         def self.autocorrect_incompatible_with
-          [Style::SymbolProc]
+          [Style::BlockDelimiters, Style::SymbolProc]
         end
 
         def on_block(node)

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

@@ -117,7 +117,7 @@ module RuboCop
           elsif style == :space
             SpaceCorrector.add_space(processed_source, corrector, left, right)
           else
-            compact_corrections(corrector, tokens, left, right)
+            compact_corrections(corrector, node, tokens, left, right)
           end
         end
 
@@ -178,6 +178,8 @@ module RuboCop
             space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
 
+          return if closing_bracket_kept_apart?(node, tokens, left, right)
+
           if qualifies_for_compact?(tokens, right)
             compact_offense(node, right)
           elsif !multi_dimensional_array?(tokens, right)
@@ -212,13 +214,24 @@ module RuboCop
           end
         end
 
-        def compact_corrections(corrector, tokens, left, right)
+        # A closing bracket on its own line is only collapsed when the opening
+        # bracket ends up on the first element's line, so that the brackets
+        # stay symmetrical (see `Layout/MultilineArrayBraceLayout`).
+        def closing_bracket_kept_apart?(node, tokens, left, right)
+          end_has_own_line?(right) &&
+            !multi_dimensional_array?(tokens, left, side: :left) &&
+            !same_line?(left, node.children.first)
+        end
+
+        def compact_corrections(corrector, node, tokens, left, right)
           if multi_dimensional_array?(tokens, left, side: :left)
             compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
 
+          return if closing_bracket_kept_apart?(node, tokens, left, right)
+
           if multi_dimensional_array?(tokens, right)
             compact(corrector, right, :left)
           elsif !right.space_before?

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

@@ -153,7 +153,7 @@ module RuboCop
           else
             column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(inner, right_brace, column)
+                      aligned_braces?(inner, right_brace, column, left_brace)
 
             space_inside_right_brace(inner, right_brace, column)
           end
@@ -163,14 +163,21 @@ module RuboCop
           left_brace.first_line != right_brace.first_line
         end
 
-        def aligned_braces?(inner, right_brace, column)
-          column == right_brace.column || column == inner_last_space_count(inner)
+        def aligned_braces?(inner, right_brace, column, left_brace)
+          column == right_brace.column ||
+            column == inner_last_space_count(inner) ||
+            aligned_with_opening_brace_line?(left_brace, right_brace)
         end
 
         def inner_last_space_count(inner)
           inner.split("\n").last.count(' ')
         end
 
+        def aligned_with_opening_brace_line?(left_brace, right_brace)
+          begins_its_line?(right_brace) &&
+            right_brace.column == left_brace.source_line[/\A\s*/].length
+        end
+
         def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
@@ -197,9 +204,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
-            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
-                  'Space inside { detected.')
+            space_after_left_brace(left_brace)
           end
         end
 
@@ -207,6 +212,20 @@ module RuboCop
           args_delimiter&.is?('|')
         end
 
+        def space_after_left_brace(left_brace)
+          brace_with_space = range_with_surrounding_space(left_brace, side: :right)
+          return if brace_with_space.source.match?(/\R/)
+          return if comment_at?(brace_with_space.end_pos)
+
+          space(
+            brace_with_space.begin_pos + 1, brace_with_space.end_pos, 'Space inside { detected.'
+          )
+        end
+
+        def comment_at?(pos)
+          processed_source.comments.any? { |comment| comment.source_range.begin_pos == pos }
+        end
+
         def space_inside_right_brace(inner, right_brace, column)
           brace_with_space = range_with_surrounding_space(right_brace, side: :left)
           begin_pos = brace_with_space.begin_pos
@@ -216,7 +235,7 @@ module RuboCop
             begin_pos = end_pos - (right_brace.column - column)
           end
 
-          if inner.end_with?(']')
+          if closing_bracket_on_own_line?(inner)
             end_pos -= 1
             begin_pos = end_pos - (inner_last_space_count(inner) - column)
           end
@@ -224,6 +243,10 @@ module RuboCop
           space(begin_pos, end_pos, 'Space inside } detected.')
         end
 
+        def closing_bracket_on_own_line?(inner)
+          inner[/[^\n]*\z/].match?(/\A\s*\]\z/)
+        end
+
         def no_space(begin_pos, end_pos, msg)
           if style == :space
             offense(begin_pos, end_pos, msg)
@@ -241,7 +264,7 @@ module RuboCop
         end
 
         def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
-          return if begin_pos > end_pos
+          return if begin_pos >= end_pos
 
           range = range_between(begin_pos, end_pos)
           add_offense(range, message: msg) do |corrector|

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_operator.rb

@@ -37,7 +37,7 @@ module RuboCop
                      'should be %<possible>s.'
 
         def self.autocorrect_incompatible_with
-          [Naming::BlockForwarding]
+          [Naming::BlockForwarding, Style::ArgumentsForwarding]
         end
 
         def on_new_investigation

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

@@ -56,7 +56,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return if node.parenthesized?
+          # `foo.*` is a regular method call, not a binary operator.
+          return if node.parenthesized? || node.loc.dot
 
           return unless (parent = node.parent)
           return unless operator?(parent)

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/empty_conditional_body.rb

@@ -97,12 +97,14 @@ module RuboCop
         end
 
         def can_simplify_conditional?(node)
-          node.else_branch && node.loc.else.source == 'else'
+          !node.elsif? && node.else_branch && node.loc.else.source == 'else'
         end
 
         def remove_empty_branch(corrector, node)
           range = if empty_if_branch?(node) && else_branch?(node)
                     branch_range(node)
+                  elsif node.condition.last_line == node.loc.else.line
+                    node.source_range.with(end_pos: node.loc.else.begin_pos)
                   else
                     deletion_range(branch_range(node))
                   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/literal_as_condition.rb

@@ -98,6 +98,8 @@ module RuboCop
             end
           elsif node.condition.falsey_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -127,6 +129,8 @@ module RuboCop
             end
           elsif node.condition.truthy_literal?
             add_offense(node.condition) do |corrector|
+              next if orphans_loop_control_keyword?(node)
+
               corrector.replace(node, node.body.child_nodes.map(&:source).join("\n"))
             end
           end
@@ -175,6 +179,15 @@ module RuboCop
 
         private
 
+        # Unwrapping the body of a loop that runs once would leave a `break`,
+        # `next` or `redo` that belongs to it outside of any loop.
+        def orphans_loop_control_keyword?(node)
+          node.body.each_node(:next, :break, :redo).any? do |control|
+            inner = control.each_ancestor.take_while { |ancestor| !ancestor.equal?(node) }
+            inner.none? { |ancestor| ancestor.any_block_type? || ancestor.loop_keyword? }
+          end
+        end
+
         def void_value_expression?(node)
           node = node.children.last while node&.begin_type?
 
@@ -273,6 +286,8 @@ module RuboCop
                        "#{node.else_branch.source.sub('elsif', 'if')}\nend"
                      elsif node.else? || node.ternary?
                        node.else_branch.source
+                     elsif node.value_used?
+                       'nil'
                      else
                        '' # Equivalent to removing the node
                      end