rubocop 1.91.0 → 1.92.1

data/lib/rubocop/cop/internal_affairs/node_type_group.rb

@@ -46,13 +46,6 @@ module RuboCop
 
         private
 
-        def arguments_range(node)
-          range_between(
-            node.first_argument.source_range.begin_pos,
-            node.last_argument.source_range.end_pos
-          )
-        end
-
         def group_satisfied?(group_types, symbol_args)
           group_types.all? { |type| symbol_args.any? { |arg| arg.value == type } }
         end

data/lib/rubocop/cop/internal_affairs/redundant_context_config_parameter.rb

@@ -31,15 +31,9 @@ module RuboCop
             dup_arguments = arguments.dup
             dup_arguments.delete(config_node)
 
-            corrector.replace(offense_range(arguments), dup_arguments.map(&:source).join(', '))
+            corrector.replace(arguments_range(node), dup_arguments.map(&:source).join(', '))
           end
         end
-
-        private
-
-        def offense_range(arguments)
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        end
       end
     end
   end

data/lib/rubocop/cop/internal_affairs/style_detected_api_use.rb

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def on_if(node)
-          traverse_condition(node.condition) do |cond|
+          node.condition.each_node(:send) do |cond|
             add_offense(cond, message: MSG_FOR_CONDITIONAL_USE) if style_detected_api_used?(cond)
           end
         end
@@ -134,12 +134,6 @@ module RuboCop
             no_acceptable_style_check(node) ||
             style_detected_check(node)
         end
-
-        def traverse_condition(condition, &block)
-          yield condition if condition.send_type?
-
-          condition.each_child_node { |child| traverse_condition(child, &block) }
-        end
       end
     end
   end

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

@@ -53,7 +53,7 @@ module RuboCop
 
         def on_send(node)
           return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
-                    autocorrect_incompatible_with_other_cops?
+                    binary_operator_call?(node) || autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)
 
@@ -64,6 +64,10 @@ module RuboCop
 
         private
 
+        def binary_operator_call?(node)
+          node.binary_operation? && !node.method?(:[]) && !node.loc.dot
+        end
+
         def autocorrect_incompatible_with_other_cops?
           with_first_argument_style? && enforce_hash_argument_with_separator?
         end

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
@@ -333,9 +341,26 @@ module RuboCop
 
             return "#{node_visibility(node)}_methods"
           end
+          return class_method_category(node) if node.defs_type?
+
           HUMANIZED_NODE_TYPE[node.type] || node.type
         end
 
+        # Only `private_class_method` reaches a singleton method; a bare `private` does not.
+        # Such a call follows the definition it names, so only right siblings are searched.
+        def class_method_category(node)
+          modifier = node.right_siblings.reverse.find do |sibling|
+            class_method_visibility_modifier?(sibling, method_name: node.method_name)
+          end
+
+          modifier ? :"#{modifier.method_name}s" : HUMANIZED_NODE_TYPE[node.type]
+        end
+
+        # @!method class_method_visibility_modifier?(node, method_name:)
+        def_node_matcher :class_method_visibility_modifier?, <<~PATTERN
+          (send nil? {:private_class_method :public_class_method} <(sym %method_name) ...>)
+        PATTERN
+
         def dynamic_constant?(node)
           return false unless node.casgn_type? && node.namespace.nil?
 
@@ -421,12 +446,9 @@ module RuboCop
         end
 
         def end_position_for(node)
-          if node.casgn_type?
-            heredoc = find_heredoc(node)
-            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
-          end
+          heredoc_end_lines = heredocs(node).map { |heredoc| heredoc.loc.heredoc_end.line }
+          end_line = [node.last_line, *heredoc_end_lines].max
 
-          end_line = buffer.line_for_position(node.source_range.end_pos)
           buffer.line_range(end_line).end_pos
         end
 
@@ -449,8 +471,8 @@ module RuboCop
           buffer.line_range(node.loc.line).begin_pos - 1
         end
 
-        def find_heredoc(node)
-          node.each_node(:any_str).find(&:heredoc?)
+        def heredocs(node)
+          node.each_node(:any_str).select(&:heredoc?)
         end
 
         def buffer

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

@@ -27,10 +27,6 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        def self.autocorrect_incompatible_with
-          [Style::RedundantSelf]
-        end
-
         def on_send(node)
           return unless node.dot? || node.safe_navigation?
 
@@ -46,21 +42,35 @@ module RuboCop
 
         private
 
+        # The dot and the gap it moves across are replaced in one action, so that another
+        # correction that rewrites a range spanning the dot clashes with this one instead of
+        # leaving the moved dot behind.
         def autocorrect(corrector, dot, node)
-          dot_range = if processed_source[dot.line - 1].strip == '.'
-                        range_by_whole_lines(dot, include_final_newline: true)
-                      else
-                        dot
-                      end
-          corrector.remove(dot_range)
-          case style
-          when :leading
-            corrector.insert_before(selector_range(node), dot.source)
-          when :trailing
-            corrector.insert_after(node.receiver, dot.source)
+          dot_range = removed_dot_range(dot)
+
+          if style == :leading
+            move_dot_before_selector(corrector, dot, dot_range, selector_range(node))
+          else
+            move_dot_after_receiver(corrector, dot, dot_range, node.receiver)
           end
         end
 
+        def removed_dot_range(dot)
+          return dot unless processed_source[dot.line - 1].strip == '.'
+
+          range_by_whole_lines(dot, include_final_newline: true)
+        end
+
+        def move_dot_before_selector(corrector, dot, dot_range, selector)
+          gap = range_between(dot_range.end_pos, selector.begin_pos)
+          corrector.replace(dot_range.join(gap), "#{gap.source}#{dot.source}")
+        end
+
+        def move_dot_after_receiver(corrector, dot, dot_range, receiver)
+          gap = range_between(receiver.source_range.end_pos, dot_range.begin_pos)
+          corrector.replace(gap.join(dot_range), "#{dot.source}#{gap.source}")
+        end
+
         def message(dot)
           "Place the #{dot.source} on the " +
             case style

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

@@ -61,21 +61,23 @@ module RuboCop
           return if node.ternary?
 
           if node.modifier_form?
-            check_condition(node.condition) if node.right_sibling
+            check_condition(node.condition, node.right_sibling) if followed_by_statement?(node)
           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? && !followed_by_statement?(node)
+
+          check_condition(node.condition, node.modifier_form? ? node.right_sibling : node.body)
         end
         alias on_until on_while
 
         def on_while_post(node)
-          return unless node.right_sibling
+          return unless followed_by_statement?(node)
 
-          check_condition(node.condition)
+          check_condition(node.condition, node.right_sibling)
         end
         alias on_until_post on_while_post
 
@@ -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,14 @@ module RuboCop
 
         private
 
-        def check_condition(condition)
+        def followed_by_statement?(node)
+          node.parent&.type?(:begin, :kwbegin) && node.right_sibling
+        end
+
+        def check_condition(condition, following_node)
           return unless condition.multiline?
           return if next_line_empty?(condition.last_line)
+          return if body_on_line?(following_node, condition.last_line)
 
           add_offense(condition, &autocorrect(condition))
         end
@@ -113,6 +122,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,13 +38,19 @@ module RuboCop
         KIND = 'block'
 
         def on_block(node)
-          first_line = node.send_node.last_line
-
-          check(node, node.body, adjusted_first_line: first_line)
+          check(node, node.body, adjusted_first_line: body_start_line(node))
         end
 
         alias on_numblock on_block
         alias on_itblock on_block
+
+        private
+
+        def body_start_line(node)
+          return node.loc.begin.line unless node.arguments?
+
+          [node.loc.begin.line, node.arguments.last_line].max
+        end
       end
     end
   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
 
@@ -175,13 +177,7 @@ module RuboCop
           when :keyword
             node
           when :variable
-            align_to = alignment_node_for_variable_style(node)
-
-            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
-              align_to = parent
-            end
-
-            align_to
+            alignment_node_for_variable_style(node)
           else
             start_line_range(node)
           end
@@ -207,7 +203,13 @@ 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)
+            elsif ancestor.send_type?
+              leading_node(ancestor.last_argument).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
+          [Layout::RedundantLineBreak, Style::SelfAssignment]
+        end
+
         def on_new_investigation
           return if processed_source.blank?
 

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

@@ -152,6 +152,10 @@ module RuboCop
 
         MSG = 'Indent the first argument one step more than %<base>s.'
 
+        def self.autocorrect_incompatible_with
+          [Layout::ArgumentAlignment, Layout::HashAlignment]
+        end
+
         def on_send(node)
           return unless should_check?(node)
           return if same_line?(node, node.first_argument)
@@ -180,7 +184,13 @@ module RuboCop
 
           top_level_send = find_top_level_send(send_node)
           node_to_correct =
-            should_correct_entire_chain?(send_node, top_level_send) ? top_level_send : node
+            if should_correct_entire_chain?(send_node, top_level_send)
+              top_level_send
+            elsif hash_elements_aligned_by_argument_alignment?(node)
+              node.children.first
+            else
+              node
+            end
 
           AlignmentCorrector.correct(corrector, processed_source, node_to_correct, column_delta)
         end
@@ -189,6 +199,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
@@ -209,6 +220,21 @@ module RuboCop
           top_level_send
         end
 
+        # `Layout/ArgumentAlignment` with `with_fixed_indentation` indents the pairs of an
+        # unbraced hash to a fixed column, so they must not move along with the first element.
+        def hash_elements_aligned_by_argument_alignment?(node)
+          return false if !node.hash_type? || node.braces?
+          return false unless enforce_first_argument_with_fixed_indentation?
+
+          argument_alignment_applies?(node.parent) && !enforce_hash_argument_with_separator?
+        end
+
+        def enforce_hash_argument_with_separator?
+          HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
+            config.for_enabled_cop('Layout/HashAlignment')[style]&.include?('separator')
+          end
+        end
+
         def bare_operator?(node)
           node.operator_method? && !node.dot?
         end

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for a line break before the first element in a
       # multi-line array.
       #
+      # NOTE: An array whose first element is an array literal is not checked when
+      # `Layout/SpaceInsideArrayLiteralBrackets` is enabled with `EnforcedStyle: compact`,
+      # since that style joins the two opening brackets.
+      #
       # @example
       #
       #   # bad
@@ -70,6 +74,7 @@ module RuboCop
         def on_array(node)
           return if !node.loc.begin && !assignment_on_same_line?(node)
           return if allow_implicit_array_brackets? && !node.bracketed?
+          return if compact_nested_array?(node)
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
@@ -85,6 +90,16 @@ module RuboCop
           !!cop_config['AllowImplicitArrayLiterals']
         end
 
+        def compact_nested_array?(node)
+          node.square_brackets? && node.children.first&.source&.start_with?('[') &&
+            compact_array_brackets_enforced?
+        end
+
+        def compact_array_brackets_enforced?
+          config.cop_enabled?('Layout/SpaceInsideArrayLiteralBrackets') &&
+            config.for_cop('Layout/SpaceInsideArrayLiteralBrackets')['EnforcedStyle'] == 'compact'
+        end
+
         def ignore_last_element?
           !!cop_config['AllowMultilineFinalElement']
         end