rubocop 1.90.0 → 1.92.0

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

@@ -64,10 +64,10 @@ module RuboCop
           autocorrect_one(corrector, comment)
         end
 
-        # Corrects all comment lines that occur immediately before the given
-        # comment and have the same indentation. This is to avoid a long chain
-        # of correcting, saving the file, parsing and inspecting again, and
-        # then correcting one more line, and so on.
+        # Corrects all preceding comment lines that have the same indentation
+        # and are separated from the given comment by nothing but blank lines.
+        # This is to avoid a long chain of correcting, saving the file, parsing
+        # and inspecting again, and then correcting one more line, and so on.
         def autocorrect_preceding_comments(corrector, comment)
           comments = processed_source.comments
           index = comments.index(comment)
@@ -82,7 +82,10 @@ module RuboCop
         def should_correct?(preceding_comment, reference_comment)
           loc = preceding_comment.loc
           ref_loc = reference_comment.loc
-          loc.line == ref_loc.line - 1 && loc.column == ref_loc.column
+          return false unless loc.column == ref_loc.column
+          return false unless own_line_comment?(preceding_comment)
+
+          ((loc.line + 1)...ref_loc.line).all? { |line| processed_source[line - 1].blank? }
         end
 
         def autocorrect_one(corrector, comment)

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

@@ -93,6 +93,7 @@ module RuboCop
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
           when :block, :numblock, :itblock then start_line_range(parent)
+          when :class, :module, :sclass then parent.loc.keyword
           else node.loc.keyword
           end
         end

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

@@ -91,7 +91,7 @@ module RuboCop
         end
 
         def next_line_node(node)
-          return if node.parent.if_type?
+          return if node.parent.type?(:if, :rescue, :ensure)
 
           node.right_sibling
         end

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

@@ -89,15 +89,16 @@ module RuboCop
               'in an array, relative to %<base_description>s.'
 
         def on_array(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+          return unless node.loc.begin
+          return if autocorrect_incompatible_with_other_cops?(node, nil)
 
-          check(node, nil) if node.loc.begin
+          check(node, nil)
         end
 
         def on_send(node)
-          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
-
           each_argument_node(node, :array) do |array_node, left_parenthesis|
+            next if autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+
             check(array_node, left_parenthesis)
           end
         end
@@ -105,6 +106,18 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(array_node, left_parenthesis)
+          return false unless enforce_first_argument_with_fixed_indentation?
+          return true if style != :consistent
+
+          # `Layout/ArrayAlignment` does not align single-element arrays.
+          return false if array_node.children.size < 2
+
+          _base_column, indent_base_type =
+            indent_base(array_node.loc.begin, array_node.values.first, left_parenthesis)
+          indent_base_type != :start_of_line
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         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/first_parameter_indentation.rb

@@ -53,6 +53,7 @@ module RuboCop
         def on_def(node)
           return if node.arguments.empty?
           return if node.arguments.loc.begin.nil?
+          return if autocorrect_incompatible_with_other_cops?(node)
 
           check(node)
         end
@@ -60,6 +61,11 @@ module RuboCop
 
         private
 
+        def autocorrect_incompatible_with_other_cops?(node)
+          node.arguments.size >= 2 &&
+            style == :align_parentheses && enforce_parameter_with_fixed_indentation?
+        end
+
         def autocorrect(corrector, node)
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
@@ -95,6 +101,11 @@ module RuboCop
             base_description: base_description
           )
         end
+
+        def enforce_parameter_with_fixed_indentation?
+          parameter_alignment_config = config.for_enabled_cop('Layout/ParameterAlignment')
+          parameter_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
       end
     end
   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,14 +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, key_delta, key)
-        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
@@ -341,9 +349,6 @@ module RuboCop
           value_delta     = delta[:value]     || 0
           key_delta       = delta[:key]       || 0
 
-          key_column = key.column
-          key_delta = -key_column if key_delta < -key_column
-
           adjust(corrector, key_delta, key)
           adjust(corrector, separator_delta, separator)
           adjust(corrector, value_delta, value)

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
@@ -400,7 +400,7 @@ module RuboCop
           if body_node.rescue_type?
             check_rescue?(body_node)
           elsif body_node.ensure_type?
-            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring
+            block_body, = *body_node # rubocop:disable InternalAffairs/NodeDestructuring -- `EnsureNode` has no accessor for the protected body
             if block_body&.rescue_type?
               check_rescue?(block_body)
             else
@@ -440,7 +440,7 @@ module RuboCop
                   begin_pos - indentation
                 end
 
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+          pos = ind <= begin_pos ? ind..begin_pos : begin_pos..ind
           range_between(pos.begin, pos.end)
         end