rubocop 1.91.0 → 1.92.0

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

@@ -68,6 +68,7 @@ module RuboCop
       #   end
       #
       class BlockAlignment < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -154,6 +155,32 @@ module RuboCop
                           else
                             start_for_line_node(node)
                           end
+
+          if using_tabs? && (indentation = anchor_indentation(ancestor_node, node))
+            replace_end_indentation(corrector, node, indentation)
+          else
+            shift_end_to_start_col(corrector, ancestor_node, node)
+          end
+        end
+
+        def anchor_indentation(ancestor_node, node)
+          if style == :start_of_block
+            do_line_anchor_loc(node, node.loc.begin).source_line[/\A\s*/]
+          else
+            anchor_loc = (ancestor_node || node).source_range
+            anchor_loc.source_line[/\A\s*/] if begins_its_line?(anchor_loc)
+          end
+        end
+
+        def replace_end_indentation(corrector, node, indentation)
+          loc_end = node.loc.end
+          whitespace = range_between(loc_end.begin_pos - loc_end.column, loc_end.begin_pos)
+          return if whitespace.source == indentation
+
+          corrector.replace(whitespace, indentation)
+        end
+
+        def shift_end_to_start_col(corrector, ancestor_node, node)
           start_col = compute_start_col(ancestor_node, node)
           loc_end = node.loc.end
           delta = start_col - loc_end.column

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

@@ -164,8 +164,12 @@ module RuboCop
           cop_config['IndentOneStep']
         end
 
+        # Under tabs one step is a single tab character, which counts as one column
+        # regardless of the configured indentation width.
         def indentation_width
-          indent_one_step? ? configured_indentation_width : 0
+          return 0 unless indent_one_step?
+
+          using_tabs? ? 1 : configured_indentation_width
         end
 
         def incorrect_style(when_node, branch_type)
@@ -176,8 +180,10 @@ module RuboCop
             detect_incorrect_style(when_node)
 
             whitespace = whitespace_range(when_node)
+            next unless whitespace.source.strip.empty?
 
-            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
+            indentation = replacement(when_node)
+            corrector.replace(whitespace, indentation) if indentation
           end
         end
 
@@ -193,10 +199,7 @@ module RuboCop
         end
 
         def base_column(case_node, base)
-          case base
-          when :case then case_node.location.keyword.column
-          when :end  then case_node.location.end.column
-          end
+          base_location(case_node, base)&.column
         end
 
         def whitespace_range(node)
@@ -207,13 +210,26 @@ module RuboCop
         end
 
         def replacement(node)
+          base_loc = configured_base_location(node)
+
+          return ' ' * (base_loc.column + indentation_width) unless using_tabs?
+          return unless begins_its_line?(base_loc)
+
+          base_loc.source_line[/\A\s*/] + ("\t" * indentation_width)
+        end
+
+        def configured_base_location(node)
           case_node = node.each_ancestor(:case, :case_match).first
           base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
 
-          column = base_column(case_node, base_type)
-          column += indentation_width
+          base_location(case_node, base_type)
+        end
 
-          ' ' * column
+        def base_location(case_node, base)
+          case base
+          when :case then case_node.location.keyword
+          when :end  then case_node.location.end
+          end
         end
       end
     end

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

@@ -188,6 +188,14 @@ module RuboCop
 
         MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
 
+        # A moved element is inserted before the line break that precedes its anchor.
+        # When the anchor follows a blank line, `Layout/EmptyLines`,
+        # `Layout/EmptyLinesAroundAccessModifier` or `Layout/EmptyLinesAroundClassBody`
+        # may remove that line break in the same pass.
+        def self.autocorrect_incompatible_with
+          [Layout::EmptyLines, Layout::EmptyLinesAroundAccessModifier, Layout::EmptyLinesAroundClassBody]
+        end
+
         # Validates code style on class declaration.
         # Add offense when find a node out of expected order.
         # A node is out of order when its category is expected earlier than
@@ -423,7 +431,7 @@ module RuboCop
         def end_position_for(node)
           if node.casgn_type?
             heredoc = find_heredoc(node)
-            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+            return heredoc.location.heredoc_end.end_pos if heredoc
           end
 
           end_line = buffer.line_for_position(node.source_range.end_pos)

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

@@ -49,6 +49,10 @@ module RuboCop
           return unless node.def_modifier?
 
           method_def = node.each_descendant(:any_def).first
+          # A single-line `def` has nothing to align, even when a line
+          # continuation puts it on a later line than the modifier.
+          return if method_def.single_line?
+
           expr = node.source_range
 
           line_start = range_between(expr.begin_pos, method_def.loc.keyword.end_pos)

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

@@ -63,12 +63,14 @@ module RuboCop
           if node.modifier_form?
             check_condition(node.condition) if node.right_sibling
           else
-            check_condition(node.condition)
+            check_condition(node.condition, node.if_branch)
           end
         end
 
         def on_while(node)
-          check_condition(node.condition)
+          return if node.modifier_form? && !node.right_sibling
+
+          check_condition(node.condition, node.modifier_form? ? nil : node.body)
         end
         alias on_until on_while
 
@@ -84,7 +86,8 @@ module RuboCop
             last_condition = when_node.conditions.last
 
             next if !multiline_when_condition?(when_node) ||
-                    next_line_empty?(last_condition.last_line)
+                    next_line_empty?(last_condition.last_line) ||
+                    body_on_line?(when_node.body, last_condition.last_line)
 
             add_offense(when_node, &autocorrect(last_condition))
           end
@@ -94,7 +97,8 @@ module RuboCop
           node.resbody_branches.each do |resbody|
             rescued_exceptions = resbody.exceptions
             next if !multiline_rescue_exceptions?(rescued_exceptions) ||
-                    next_line_empty?(rescued_exceptions.last.last_line)
+                    next_line_empty?(rescued_exceptions.last.last_line) ||
+                    body_on_line?(resbody.body, rescued_exceptions.last.last_line)
 
             add_offense(resbody, &autocorrect(rescued_exceptions.last))
           end
@@ -102,9 +106,10 @@ module RuboCop
 
         private
 
-        def check_condition(condition)
+        def check_condition(condition, body = nil)
           return unless condition.multiline?
           return if next_line_empty?(condition.last_line)
+          return if body_on_line?(body, condition.last_line)
 
           add_offense(condition, &autocorrect(condition))
         end
@@ -113,6 +118,10 @@ module RuboCop
           processed_source[line].blank?
         end
 
+        def body_on_line?(body, line)
+          body&.first_line == line
+        end
+
         def multiline_when_condition?(when_node)
           when_node.conditions.first.first_line != when_node.conditions.last.last_line
         end

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

@@ -27,8 +27,7 @@ module RuboCop
 
         def on_new_investigation
           return if processed_source.tokens.empty?
-          # Quick check if we possibly have consecutive blank lines.
-          return unless processed_source.raw_source.include?("\n\n\n")
+          return unless consecutive_blank_lines_possible?
 
           lines = Set.new
           processed_source.tokens.each { |token| lines << token.line }
@@ -42,6 +41,10 @@ module RuboCop
 
         private
 
+        def consecutive_blank_lines_possible?
+          processed_source.buffer.source.include?("\n\n\n")
+        end
+
         def each_extra_empty_line(lines)
           prev_line = 1
 

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

@@ -111,6 +111,7 @@ module RuboCop
 
         def require_empty_line?(node)
           return false unless node.respond_to?(:type)
+          return false if node.left_sibling.last_line == node.first_line
 
           !allow_alias?(node) && !attribute_or_allowed_method?(node)
         end

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

@@ -38,7 +38,7 @@ module RuboCop
         KIND = 'block'
 
         def on_block(node)
-          first_line = node.send_node.last_line
+          first_line = node.loc.begin.line
 
           check(node, node.body, adjusted_first_line: first_line)
         end

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

@@ -85,8 +85,12 @@ module RuboCop
             next if line == line_of_def_or_kwbegin || last_body_and_end_on_same_line?(body)
 
             keyword = loc.source
+
             # below the keyword
-            check_line(style, line, message('after', keyword), &:empty?)
+            unless left_to_block_body_cop?(body, line)
+              check_line(style, line, message('after', keyword), &:empty?)
+            end
+
             # above the keyword
             check_line(style, line - 2, message('before', keyword), &:empty?)
           end
@@ -122,6 +126,15 @@ module RuboCop
           end
         end
 
+        def left_to_block_body_cop?(body, keyword_line)
+          return false unless body.parent.any_block_type?
+
+          cop_config = config.for_enabled_cop('Layout/EmptyLinesAroundBlockBody')
+          return false if cop_config['EnforcedStyle'] != 'empty_lines'
+
+          only_empty_lines_until_end?(body, keyword_line)
+        end
+
         def keyword_locations_in_rescue(node)
           [node.loc.else, *node.resbody_branches.map { |body| body.loc.keyword }].compact
         end
@@ -133,6 +146,15 @@ module RuboCop
             *keyword_locations(rescue_body_without_ensure)
           ]
         end
+
+        def only_empty_lines_until_end?(body, keyword_line)
+          end_line = body.parent.loc.end.line
+          next_line = (keyword_line + 1).upto(end_line).find do |line_number|
+            !processed_source.lines[line_number - 1].strip.empty?
+          end
+
+          next_line == end_line
+        end
       end
     end
   end

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

@@ -123,16 +123,8 @@ module RuboCop
           AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
         end
 
-        # rubocop:disable-next Metrics/CyclomaticComplexity
         def check_assignment(node, rhs)
-          # If there are method calls chained to the right hand side of the
-          # assignment, we let rhs be the receiver of those method calls before
-          # we check if it's an if/unless/while/until.
-          return unless (rhs = first_part_of_call_chain(rhs))
-
-          # If `rhs` is a `begin` node or a logical operator,
-          # unwrap to find the leading conditional.
-          rhs = rhs.child_nodes.first while rhs&.type?(:begin, :or, :and)
+          rhs = leading_node(rhs)
 
           return unless rhs&.conditional?
           return if rhs.if_type? && rhs.ternary?
@@ -151,6 +143,16 @@ module RuboCop
           ignore_node(inner_node)
         end
 
+        def leading_node(rhs)
+          # If there are method calls chained to the right hand side of the assignment,
+          # we let rhs be the receiver of those method calls.
+          rhs = first_part_of_call_chain(rhs)
+
+          # If `rhs` is a `begin` node or a logical operator, unwrap to find the leading node.
+          rhs = rhs.child_nodes.first while rhs&.type?(:begin, :or, :and)
+          rhs
+        end
+
         def asgn_variable_align_with(outer_node, inner_node)
           expr = outer_node.source_range
 
@@ -207,7 +209,11 @@ module RuboCop
 
         def assignment_or_operator_method(node)
           node.ancestors.find do |ancestor|
-            ancestor.assignment_or_similar? || (ancestor.send_type? && ancestor.operator_method?)
+            if ancestor.assignment_or_similar?
+              leading_node(extract_rhs(ancestor)).equal?(node)
+            elsif ancestor.send_type? && ancestor.operator_method?
+              !leading_node(ancestor).equal?(node)
+            end
           end
         end
       end

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

@@ -36,6 +36,10 @@ module RuboCop
         MSG_UNNECESSARY = 'Unnecessary spacing detected.'
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SelfAssignment]
+        end
+
         def on_new_investigation
           return if processed_source.blank?
 

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

@@ -189,6 +189,7 @@ module RuboCop
           return false unless style == :special_for_inner_method_call_in_parentheses
           return false unless inner_call?(top_level_send)
           return false unless display_column(send_node.source_range) < column_delta.abs
+          return false if column_delta.positive?
 
           top_level_send != send_node || begins_its_line?(top_level_send.loc.end)
         end

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

@@ -187,9 +187,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

@@ -117,6 +117,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

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_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?