rubocop 1.71.1 → 1.92.1

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

@@ -21,6 +21,23 @@ module RuboCop
       #     something
       #   RUBY
       #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   <<-RUBY.squish
+      #       something
+      #   RUBY
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   <<-RUBY.squish
+      #       something
+      #   RUBY
+      #
+      #   # good
+      #   <<~RUBY.squish
+      #     something
+      #   RUBY
+      #
       class HeredocIndentation < Base
         include Alignment
         include Heredoc
@@ -33,6 +50,15 @@ module RuboCop
                    'heredoc by using `<<~` instead of `%<current_indent_type>s`.'
         WIDTH_MSG = 'Use %<indentation_width>d spaces for indentation in a heredoc.'
 
+        # @!method squish_method?(node)
+        def_node_matcher :squish_method?, <<~PATTERN
+          (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?
@@ -44,7 +70,7 @@ module RuboCop
             expected_indent_level = base_indent_level(node) + configured_indentation_width
             return if expected_indent_level == body_indent_level
           else
-            return unless body_indent_level.zero?
+            return unless body_indent_level.zero? || heredoc_squish?(node)
           end
 
           return if line_too_long?(node)
@@ -55,17 +81,30 @@ 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|
             if heredoc_indent_type == '~'
               adjust_squiggly(corrector, node)
+            elsif heredoc_squish?(node)
+              adjust_heredoc_squish(corrector, node)
             else
               adjust_minus(corrector, node)
             end
           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}"
 
@@ -89,6 +128,7 @@ module RuboCop
         end
 
         def line_too_long?(node)
+          return false unless max_line_length
           return false if unlimited_heredoc_length?
 
           body = heredoc_body(node)
@@ -108,8 +148,9 @@ module RuboCop
           config.for_cop('Layout/LineLength')['AllowHeredoc']
         end
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
+        def adjust_heredoc_squish(corrector, node)
+          adjust_squiggly(corrector, node)
+          adjust_minus(corrector, node)
         end
 
         def adjust_squiggly(corrector, node)
@@ -159,6 +200,10 @@ module RuboCop
         def heredoc_end(node)
           node.loc.heredoc_end.source
         end
+
+        def heredoc_squish?(node)
+          active_support_extensions_enabled? && squish_method?(node.parent)
+        end
       end
     end
   end

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
 
@@ -99,7 +102,7 @@ module RuboCop
 
             if str.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif str.loc?(:begin)
               ranges << loc.expression
             end
           end

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

@@ -5,6 +5,8 @@ module RuboCop
     module Layout
       # Checks for indentation that doesn't use the specified number of spaces.
       # The indentation width can be configured using the `Width` setting. The default width is 2.
+      # The block body indentation for method chain blocks can be configured using the
+      # `EnforcedStyleAlignWith` setting.
       #
       # See also the `Layout/IndentationConsistency` cop which is the companion to this one.
       #
@@ -23,6 +25,17 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # bad
+      #   value = (
+      #   foo - bar
+      #   )
+      #
+      #   # good
+      #   value = (
+      #     foo - bar
+      #   )
+      #
       # @example AllowedPatterns: ['^\s*module']
       #   # bad
       #   module A
@@ -41,7 +54,22 @@ module RuboCop
       #     end
       #   end
       #   end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line (default)
+      #   # good
+      #   records.uniq { |el| el[:profile_id] }
+      #          .map do |message|
+      #     SomeJob.perform_later(message[:id])
+      #   end
+      #
+      # @example EnforcedStyleAlignWith: relative_to_receiver
+      #   # good
+      #   records.uniq { |el| el[:profile_id] }
+      #          .map do |message|
+      #            SomeJob.perform_later(message[:id])
+      #          end
       class IndentationWidth < Base # rubocop:disable Metrics/ClassLength
+        include ConfigurableEnforcedStyle
         include EndKeywordAlignment
         include Alignment
         include CheckAssignment
@@ -50,11 +78,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use %<configured_indentation_width>d (not %<indentation>d) ' \
-              'spaces for%<name>s indentation.'
+              '%<indentation_type>s for%<name>s indentation.'
 
         # @!method access_modifier?(node)
         def_node_matcher :access_modifier?, <<~PATTERN
-          [(send ...) access_modifier?]
+          [(send ...) bare_access_modifier?]
         PATTERN
 
         def on_rescue(node)
@@ -78,19 +106,32 @@ module RuboCop
           check_indentation(node.loc.end, node.children.first)
         end
 
+        def on_begin(node)
+          # Only a parenthesized grouping expression (e.g. `(\n  foo\n)`) has
+          # explicit delimiters. Indent the body one step from the line
+          # the opening parenthesis is on, but only when the closing parenthesis is
+          # first on its line (a body on the opening line is skipped downstream).
+          return unless parentheses?(node) && begins_its_line?(node.loc.end)
+
+          check_indentation(opening_line_start(node.loc.begin), node.children.first)
+        end
+
         def on_block(node)
           end_loc = node.loc.end
 
           return unless begins_its_line?(end_loc)
 
-          check_indentation(end_loc, node.body)
+          base_loc = block_body_indentation_base(node, end_loc)
+          check_indentation(base_loc, node.body)
 
           return unless indented_internal_methods_style?
+          return unless contains_access_modifier?(node.body)
 
           check_members(end_loc, [node.body])
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_class(node)
           base = node.loc.keyword
@@ -144,7 +185,7 @@ module RuboCop
         end
 
         def on_case_match(case_match)
-          case_match.each_in_pattern do |in_pattern_node|
+          case_match.in_pattern_branches.each do |in_pattern_node|
             check_indentation(in_pattern_node.loc.keyword, in_pattern_node.body)
           end
 
@@ -163,7 +204,18 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          return unless node
+
+          AlignmentCorrector.correct(
+            corrector, processed_source, node, @column_delta, tab_indentation: true
+          )
+        end
+
+        # Returns a range at the first non-space column of the line the opening parenthesis is on,
+        # used as the base to indent the body from.
+        def opening_line_start(begin_loc)
+          column = begin_loc.source_line =~ /\S/
+          source_range(processed_source.buffer, begin_loc.line, column)
         end
 
         def check_members(base, members)
@@ -171,7 +223,7 @@ module RuboCop
 
           return unless members.any? && members.first.begin_type?
 
-          if indentation_consistency_style == 'indented_internal_methods'
+          if indented_internal_methods_style?
             check_members_for_indented_internal_methods_style(members)
           else
             check_members_for_normal_style(base, members)
@@ -198,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
@@ -300,10 +352,32 @@ module RuboCop
         end
 
         def message(configured_indentation_width, indentation, name)
+          if using_tabs?
+            message_for_tabs(configured_indentation_width, indentation, name)
+          else
+            message_for_spaces(configured_indentation_width, indentation, name)
+          end
+        end
+
+        def message_for_tabs(configured_indentation_width, indentation, name)
+          configured_tabs = 1
+          actual_tabs = indentation / configured_indentation_width
+
+          format(
+            MSG,
+            configured_indentation_width: configured_tabs,
+            indentation: actual_tabs,
+            indentation_type: 'tabs',
+            name: name
+          )
+        end
+
+        def message_for_spaces(configured_indentation_width, indentation, name)
           format(
             MSG,
             configured_indentation_width: configured_indentation_width,
             indentation: indentation,
+            indentation_type: 'spaces',
             name: name
           )
         end
@@ -326,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
@@ -359,8 +433,14 @@ module RuboCop
         def offending_range(body_node, indentation)
           expr = body_node.source_range
           begin_pos = expr.begin_pos
-          ind = expr.begin_pos - indentation
-          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+
+          ind = if using_tabs?
+                  begin_pos - line_indentation(expr).length
+                else
+                  begin_pos - indentation
+                end
+
+          pos = ind <= begin_pos ? ind..begin_pos : begin_pos..ind
           range_between(pos.begin, pos.end)
         end
 
@@ -373,8 +453,47 @@ module RuboCop
           starting_node.send_type? && starting_node.bare_access_modifier?
         end
 
-        def configured_indentation_width
-          cop_config['Width']
+        def contains_access_modifier?(body_node)
+          return false unless body_node&.begin_type?
+
+          body_node.children.any? { |child| child.send_type? && child.bare_access_modifier? }
+        end
+
+        def indentation_style
+          config.for_cop('Layout/IndentationStyle')['EnforcedStyle'] || 'spaces'
+        end
+
+        def using_tabs?
+          indentation_style == 'tabs'
+        end
+
+        def column_offset_between(base_range, range)
+          return super unless using_tabs?
+
+          base_uses_tabs = line_uses_tabs?(base_range)
+          range_uses_tabs = line_uses_tabs?(range)
+
+          return super unless base_uses_tabs || range_uses_tabs
+
+          visual_column(base_range) - visual_column(range)
+        end
+
+        def line_indentation(range)
+          line = processed_source.lines[range.line - 1]
+          line[0...range.column]
+        end
+
+        def line_uses_tabs?(range)
+          line_indentation(range).include?("\t")
+        end
+
+        def visual_column(range)
+          indentation = line_indentation(range)
+
+          tab_count = indentation.count("\t")
+          space_count = indentation.count(' ')
+
+          (tab_count * configured_indentation_width) + space_count
         end
 
         def leftmost_modifier_of(node)
@@ -382,6 +501,34 @@ module RuboCop
 
           leftmost_modifier_of(node.parent)
         end
+
+        def block_body_indentation_base(node, end_loc)
+          return end_loc unless style == :relative_to_receiver
+
+          if dot_on_new_line?(node)
+            node.send_node.loc.dot
+          elsif selector_on_new_line?(node)
+            node.send_node.loc.selector
+          else
+            end_loc
+          end
+        end
+
+        def dot_on_new_line?(node)
+          send_node = node.send_node
+          return false unless send_node.loc?(:dot)
+
+          receiver = send_node.receiver
+          receiver && receiver.last_line < send_node.loc.dot.line
+        end
+
+        def selector_on_new_line?(node)
+          send_node = node.send_node
+          return false unless send_node.loc?(:dot) && send_node.loc?(:selector)
+
+          receiver = send_node.receiver
+          receiver && receiver.last_line < send_node.loc.selector.line
+        end
       end
     end
   end

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

@@ -58,6 +58,12 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
       # @example AllowRBSInlineAnnotation: true
       #
       #   # good
@@ -67,6 +73,12 @@ module RuboCop
       #   attr_reader :name #: String
       #   attr_reader :age  #: Integer?
       #
+      #   #: (
+      #   #|   Integer,
+      #   #|   String
+      #   #| ) -> void
+      #   def foo; end
+      #
       # @example AllowSteepAnnotation: false (default)
       #
       #   # bad
@@ -86,6 +98,24 @@ module RuboCop
       #
       #   name = 'John'      #: String
       #
+      # @example AllowYARDCommentBlockSeparator: false (default)
+      #
+      #   # bad
+      #
+      #   # Copyright (c) Example Corp
+      #   #-
+      #   class Client
+      #   end
+      #
+      # @example AllowYARDCommentBlockSeparator: true
+      #
+      #   # good
+      #
+      #   # Copyright (c) Example Corp
+      #   #-
+      #   class Client
+      #   end
+      #
       class LeadingCommentSpace < Base
         include RangeHelp
         extend AutoCorrector
@@ -101,6 +131,7 @@ module RuboCop
             next if gemfile_ruby_comment?(comment)
             next if rbs_inline_annotation?(comment)
             next if steep_annotation?(comment)
+            next if yard_comment_block_separator?(comment)
 
             add_offense(comment) do |corrector|
               expr = comment.source_range
@@ -175,7 +206,7 @@ module RuboCop
         end
 
         def rbs_inline_annotation?(comment)
-          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]/)
+          allow_rbs_inline_annotation? && comment.text.start_with?(/#:|#\[.+\]|#\|/)
         end
 
         def allow_steep_annotation?
@@ -185,6 +216,14 @@ module RuboCop
         def steep_annotation?(comment)
           allow_steep_annotation? && comment.text.start_with?(/#[$:]/)
         end
+
+        def allow_yard_comment_block_separator?
+          cop_config['AllowYARDCommentBlockSeparator']
+        end
+
+        def yard_comment_block_separator?(comment)
+          allow_yard_comment_block_separator? && comment.text.match?(/\A#-\s*\z/)
+        end
       end
     end
   end

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

@@ -87,7 +87,7 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
@@ -101,17 +101,22 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
+            elsif literal.loc?(:begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           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
 
@@ -124,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?