rubocop 1.91.0 → 1.92.1

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

@@ -156,16 +156,22 @@ module RuboCop
           if first_pair
             return if same_line?(first_pair, left_brace)
 
-            if separator_style?(first_pair)
-              check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
-            else
-              check_first(first_pair, left_brace, left_parenthesis, 0)
-            end
+            check_first_pair(hash_node, first_pair, left_brace, left_parenthesis)
           end
 
           check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
         end
 
+        def check_first_pair(hash_node, first_pair, left_brace, left_parenthesis)
+          return unless begins_its_line?(first_pair.source_range)
+
+          if separator_style?(first_pair)
+            check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+          else
+            check_first(first_pair, left_brace, left_parenthesis, 0)
+          end
+        end
+
         def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
           # if the right brace is on the same line as the last value, accept
           return if /\S/.match?(right_brace.source_line[0...right_brace.column])
@@ -187,9 +193,11 @@ module RuboCop
         end
 
         def check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
-          key_lengths = hash_node.keys.map { |key| key.source_range.length }
-          check_first(hash_node.pairs.first, left_brace, left_parenthesis,
-                      key_lengths.max - key_lengths.first)
+          first_key = hash_node.keys.first
+          key_lengths = hash_node.keys.select(&:single_line?).map { |key| key.source_range.length }
+          offset = first_key.single_line? ? key_lengths.max - first_key.source_range.length : 0
+
+          check_first(hash_node.pairs.first, left_brace, left_parenthesis, offset)
         end
 
         # Returns the description of what the correct indentation is based on.

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

@@ -75,6 +75,12 @@ module RuboCop
 
         MSG = 'Add a line break before the first argument of a multi-line method argument list.'
 
+        # A line break inserted after `(` while `Style/MethodCallWithArgsParentheses` removes
+        # the parentheses in the same pass leaves the method name alone on its line.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if allowed_method?(node.method_name)
 

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

@@ -59,6 +59,10 @@ module RuboCop
 
         MSG = 'Add a line break before the first parameter of a multi-line method parameter list.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodDefParentheses]
+        end
+
         def on_def(node)
           check_method_line_break(node, node.arguments, ignore_last: ignore_last_element?)
         end

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

@@ -215,7 +215,7 @@ module RuboCop
           check_pairs(node)
         end
 
-        attr_accessor :offenses_by, :column_deltas
+        attr_accessor :offenses_by, :column_deltas, :unalignable_styles
 
         private
 
@@ -240,6 +240,7 @@ module RuboCop
         def reset!
           self.offenses_by = {}
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+          self.unalignable_styles = []
         end
 
         def check_pairs(node)
@@ -265,7 +266,9 @@ module RuboCop
           kwsplat_offenses = offenses_by.delete(KeywordSplatAlignment)
           register_offenses_with_format(kwsplat_offenses, KeywordSplatAlignment)
 
-          format, offenses = offenses_by.min_by { |_, v| v.length }
+          candidates = offenses_by.reject { |style, _| unalignable_styles.include?(style) }
+          candidates = offenses_by if candidates.empty?
+          format, offenses = candidates.min_by { |_, v| v.length }
           register_offenses_with_format(offenses, format)
         end
 
@@ -283,10 +286,19 @@ module RuboCop
           offenses_by[alignment.class] ||= []
           return if good_alignment? delta
 
+          if key_out_of_line?(delta, node)
+            unalignable_styles << alignment.class
+            return
+          end
+
           column_deltas[alignment.class][node] = delta
           offenses_by[alignment.class].push(node)
         end
 
+        def key_out_of_line?(delta, node)
+          (delta[:key] || 0) < -node.source_range.column
+        end
+
         def ignore_hash_argument?(node)
           case cop_config['EnforcedLastArgumentHashStyle']
           when 'always_inspect'  then false
@@ -325,18 +337,10 @@ module RuboCop
                               node.loc.operator)
           else
             delta_value = delta[:key] || 0
-            correct_no_value(corrector, delta_value, node.source_range)
+            adjust(corrector, delta_value, node.source_range)
           end
         end
 
-        def correct_no_value(corrector, key_delta, key)
-          adjust(corrector, clamped_key_delta(key_delta, key), key)
-        end
-
-        def clamped_key_delta(key_delta, key)
-          [key_delta, -key.column].max
-        end
-
         def correct_key_value(corrector, delta, key, value, separator)
           # We can't use the instance variable inside the lambda. That would
           # just give each lambda the same reference and they would all get the
@@ -345,7 +349,7 @@ module RuboCop
           value_delta     = delta[:value]     || 0
           key_delta       = delta[:key]       || 0
 
-          adjust(corrector, clamped_key_delta(key_delta, key), key)
+          adjust(corrector, key_delta, key)
           adjust(corrector, separator_delta, separator)
           adjust(corrector, value_delta, value)
         end

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

@@ -57,8 +57,10 @@ module RuboCop
         MSG = 'Put the closing parenthesis for a method call with a ' \
               'HEREDOC parameter on the same line as the HEREDOC opening.'
 
+        # `Layout/MultilineMethodCallBraceLayout` can move the same closing parenthesis after
+        # the last argument in the same pass, and both insertions are kept.
         def self.autocorrect_incompatible_with
-          [Style::TrailingCommaInArguments]
+          [Layout::MultilineMethodCallBraceLayout, Style::TrailingCommaInArguments]
         end
 
         def on_send(node)
@@ -117,6 +119,8 @@ module RuboCop
           previous = heredoc
           current = previous.parent
           until send_missing_closing_parens?(current, previous, heredoc)
+            return if current&.any_block_type? && !current.send_node.equal?(previous)
+
             previous = current
             current = current.parent
             return unless previous && current
@@ -229,8 +233,8 @@ module RuboCop
         end
 
         def find_most_bottom_of_heredoc_end(arguments)
-          arguments.filter_map do |argument|
-            argument.loc.heredoc_end.end_pos if argument.loc?(:heredoc_end)
+          arguments.flat_map { |argument| argument.each_node(:any_str).to_a }.filter_map do |node|
+            node.loc.heredoc_end.end_pos if node.loc?(:heredoc_end)
           end.max
         end
 

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

@@ -55,6 +55,10 @@ module RuboCop
           (send _ {:squish :squish!})
         PATTERN
 
+        def on_new_investigation
+          @offending_heredoc_bodies = nil
+        end
+
         def on_heredoc(node)
           body = heredoc_body(node)
           return if body.strip.empty?
@@ -77,6 +81,9 @@ module RuboCop
         private
 
         def register_offense(node, heredoc_indent_type)
+          return if within_offending_heredoc?(node)
+
+          offending_heredoc_bodies << node.loc.heredoc_body
           message = message(heredoc_indent_type)
 
           add_offense(node.loc.heredoc_body, message: message) do |corrector|
@@ -90,6 +97,14 @@ module RuboCop
           end
         end
 
+        def within_offending_heredoc?(node)
+          offending_heredoc_bodies.any? { |body| body.contains?(node.source_range) }
+        end
+
+        def offending_heredoc_bodies
+          @offending_heredoc_bodies ||= []
+        end
+
         def message(heredoc_indent_type)
           current_indent_type = "<<#{heredoc_indent_type}"
 

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

@@ -178,10 +178,24 @@ module RuboCop
         end
 
         def check_normal_style(node)
-          check_alignment(
-            node.children.reject { |child| bare_access_modifier?(child) },
-            base_column_for_normal_style(node)
-          )
+          items = node.children.reject { |child| bare_access_modifier?(child) }
+
+          check_alignment(items, base_column_for_normal_style(node) || governed_base_column(items))
+        end
+
+        def governed_base_column(items)
+          return unless config.cop_enabled?('Layout/IndentationWidth')
+          return if items.empty? || indentation_width_enabled_at?(items.first)
+
+          governed_item = items.find { |item| indentation_width_enabled_at?(item) }
+
+          display_column(governed_item.source_range) if governed_item
+        end
+
+        def indentation_width_enabled_at?(node)
+          comment_config = processed_source.comment_config
+
+          comment_config.cop_enabled_at_line?('Layout/IndentationWidth', node.first_line)
         end
 
         def check_indented_internal_methods_style(node)
@@ -197,7 +211,10 @@ module RuboCop
               children_to_check.last << child
             end
           end
-          children_to_check.each { |group| check_alignment(group) }
+
+          children_to_check.each do |group|
+            check_alignment(group, governed_base_column(group))
+          end
         end
       end
     end

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

@@ -6,6 +6,9 @@ module RuboCop
       # Checks that the indentation method is consistent.
       # Either tabs only or spaces only are used for indentation.
       #
+      # With `EnforcedStyle: tabs`, spaces that follow the indenting tabs are
+      # taken to be alignment rather than indentation, and are left alone.
+      #
       # @example EnforcedStyle: spaces (default)
       #   # bad
       #   # This example uses a tab to indent bar.
@@ -67,7 +70,7 @@ module RuboCop
           match = if style == :spaces
                     line.match(/\A\s*\t+/)
                   else
-                    line.match(/\A\s* +/)
+                    line.match(/\A +/)
                   end
           return unless match
 

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

@@ -82,7 +82,7 @@ module RuboCop
 
         # @!method access_modifier?(node)
         def_node_matcher :access_modifier?, <<~PATTERN
-          [(send ...) access_modifier?]
+          [(send ...) bare_access_modifier?]
         PATTERN
 
         def on_rescue(node)
@@ -250,7 +250,7 @@ module RuboCop
 
         def check_members_for_normal_style(base, members)
           members.first.children.each do |member|
-            next if member.send_type? && member.access_modifier?
+            next if member.send_type? && member.bare_access_modifier?
 
             check_indentation(base, member)
           end

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

@@ -111,6 +111,12 @@ module RuboCop
           comments.map(&:source_range)
         end
 
+        def output_record_separator_ranges(ast)
+          return [] if ast.nil?
+
+          ast.each_node(:gvar).select { |gvar| gvar.source == '$\\' }.map(&:source_range)
+        end
+
         def last_line(processed_source)
           last_token = processed_source.tokens.last
 
@@ -123,7 +129,8 @@ module RuboCop
 
         def ignored_ranges
           @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
-                              comment_ranges(processed_source.comments)
+                              comment_ranges(processed_source.comments) +
+                              output_record_separator_ranges(processed_source.ast)
         end
 
         def ignored_parent?(node)

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

@@ -87,10 +87,10 @@ module RuboCop
           return if children.empty?
 
           if style == :aligned && !always_indented?(node)
-            check_aligned(children, 1)
+            check_aligned(children, 1, children[0].loc.column)
           else
             check_indented(children)
-            check_aligned(children, 2)
+            check_aligned(children, 2, indented_column(children))
           end
         end
 
@@ -110,21 +110,37 @@ module RuboCop
           PARENT_TYPES_FOR_INDENTED.include?(dstr_node.parent&.type)
         end
 
-        def check_aligned(children, start_index)
+        def check_aligned(children, start_index, target_column)
           base_column = children[start_index - 1].loc.column
-          children[start_index..].each do |child|
-            @column_delta = base_column - child.loc.column
-            add_offense_and_correction(child, MSG_ALIGN) if @column_delta != 0
-            base_column = child.loc.column
+          same_column_runs(children[start_index..]).each do |run|
+            column = run.first.loc.column
+            if column != base_column && column != target_column
+              register_misaligned_run(run, target_column - column)
+            end
+            base_column = column
+          end
+        end
+
+        def same_column_runs(parts)
+          parts.chunk_while { |a, b| a.loc.column == b.loc.column }
+        end
+
+        def register_misaligned_run(run, column_delta)
+          @column_delta = column_delta
+          add_offense(run.first, message: MSG_ALIGN) do |corrector|
+            run.each { |child| autocorrect(corrector, child) }
           end
         end
 
         def check_indented(children)
-          @column_delta = base_column(children[0]) + configured_indentation_width -
-                          children[1].loc.column
+          @column_delta = indented_column(children) - children[1].loc.column
           add_offense_and_correction(children[1], MSG_INDENT) if @column_delta != 0
         end
 
+        def indented_column(children)
+          base_column(children[0]) + configured_indentation_width
+        end
+
         def base_column(child)
           grandparent = child.parent.parent
           if grandparent&.pair_type?

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

@@ -72,6 +72,22 @@ module RuboCop
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
+        # A trailing backslash, or a trailing unicode, hex, octal, meta or control escape whose
+        # payload may be incomplete. An even run of backslashes is complete on its own.
+        # Meta and control prefixes chain (`\M-\C-x`, `\c\M-x`), so a whole chain is one escape,
+        # and a braced unicode escape may hold several space-separated codepoints.
+        ESCAPE_SEQUENCE_TAIL = /
+          (?<!\\)(?:\\\\)*
+          (
+            \\(?:(?:[MC]-|c)\\)*
+            (?:u\{[\da-f\x20]*|u[\da-f]{0,4}|x[\da-f]{0,2}|[0-7]{0,3}|[MC]-?|c)?
+          )\z
+        /xi.freeze
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::MethodDefParentheses]
+        end
+
         def on_block(node)
           check_for_breakable_block(node)
         end
@@ -106,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
 
@@ -191,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
@@ -201,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|
@@ -214,12 +246,15 @@ module RuboCop
           return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
+          return if breakable_string_delimiters[line_index]
+
           range = breakable_block_range(block_node)
           pos = range.begin_pos + 1
 
           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]
@@ -230,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
@@ -282,7 +318,33 @@ module RuboCop
           return if source_range.last_column < max
           return unless (pos = breakable_string_range(node))
 
-          pos.end_pos unless pos.end_pos == source_range.begin_pos
+          content_begin_pos = node.loc?(:begin) ? node.loc.begin.end_pos : source_range.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
@@ -294,24 +356,57 @@ module RuboCop
           relevant_substr = largest_possible_string(node)
 
           if (space_pos = breakable_space_position(node, relevant_substr))
-            source_range.resize(space_pos + 1)
-          elsif (escape_pos = relevant_substr.rindex(/\\(u[\da-f]{0,4}|x[\da-f]{0,2})?\z/))
+            # A space can separate codepoints inside a braced unicode escape.
+            escape_pos = escape_sequence_start(relevant_substr[0..space_pos])
+            source_range.resize(escape_pos || (space_pos + 1))
+          elsif (escape_pos = escape_sequence_start(relevant_substr))
             source_range.resize(escape_pos)
           else
-            adjustment = max - source_range.last_column - 3
-            return if adjustment.abs > source_range.size
-
-            source_range.adjust(end_pos: adjustment)
+            breakable_string_range_at_limit(source_range)
           end
         end
 
         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
+
+        def breakable_string_range_at_limit(source_range)
+          adjustment = max - source_range.last_column - 3
+          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
 
@@ -320,7 +415,18 @@ module RuboCop
 
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
+          return unless source_range.column < max && source_range.last_column >= max
+          return if opens_string?(node)
+
+          source_range.begin_pos
+        end
+
+        def opens_string?(begin_node)
+          quote = begin_node.parent.loc.begin
+
+          return false unless quote
+
+          blank_between?(quote.end_pos, begin_node.source_range.begin_pos)
         end
 
         def breakable_range_by_line_index
@@ -335,6 +441,10 @@ module RuboCop
           @breakable_string_delimiters ||= {}
         end
 
+        def breakable_strings
+          @breakable_strings ||= {}
+        end
+
         def heredocs
           @heredocs ||= extract_heredocs(processed_source.ast)
         end
@@ -391,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
@@ -511,16 +649,10 @@ module RuboCop
           # `Max` - end delimiter (quote) - continuation characters (space and slash)
           max_length = max - 3
           # Offset by the string's starting column so the broken line actually fits
-          # within `Max`. When on the same line as its parent, use the column difference;
-          # otherwise the string is indented on its own line, so subtract that indentation.
-          # (Without this, an indented string under a multi-line parent never shortens
-          # below `Max` and the autocorrect loops, inserting empty `"" \` fragments.)
-          max_length -= if same_line?(node, node.parent)
-                          column_offset_between(node.loc, node.parent.loc)
-                        else
-                          node.loc.column
-                        end
-          node.source[0...(max_length)]
+          # within `Max`, whatever precedes the string on its line.
+          max_length -= node.loc.column
+
+          node.source[0, [max_length, 0].max]
         end
       end
     end

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

@@ -106,6 +106,18 @@ module RuboCop
         ALWAYS_SAME_LINE_MESSAGE = 'The closing array brace must be on the ' \
                                    'same line as the last array element.'
 
+        # Moving the closing bracket after a hash literal or method call element while
+        # `Layout/MultilineHashBraceLayout` or `Layout/MultilineMethodCallBraceLayout` moves
+        # that element's closing brace in the same pass places the bracket after whatever
+        # follows the moved brace, such as a comment.
+        # Moving it while `Style/ConcatArrayLiterals` removes the brackets in the same pass
+        # leaves the bracket behind.
+        def self.autocorrect_incompatible_with
+          [
+            Layout::MultilineHashBraceLayout, Layout::MultilineMethodCallBraceLayout, Style::ConcatArrayLiterals
+          ]
+        end
+
         def on_array(node)
           check_brace_layout(node)
         end