rubocop 1.71.1 → 1.88.2

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,11 @@ 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_heredoc(node)
           body = heredoc_body(node)
           return if body.strip.empty?
@@ -44,7 +66,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)
@@ -60,6 +82,8 @@ module RuboCop
           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
@@ -89,6 +113,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 +133,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 +185,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_style.rb

@@ -99,7 +99,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,7 +78,7 @@ 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
@@ -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,15 +204,24 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          return unless node
+
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         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)
           check_indentation(base, select_check_member(members.first))
 
           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)
@@ -300,10 +350,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
@@ -359,7 +431,13 @@ module RuboCop
         def offending_range(body_node, indentation)
           expr = body_node.source_range
           begin_pos = expr.begin_pos
-          ind = expr.begin_pos - indentation
+
+          ind = if using_tabs?
+                  begin_pos - line_indentation(expr).length
+                else
+                  begin_pos - indentation
+                end
+
           pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
           range_between(pos.begin, pos.end)
         end
@@ -373,8 +451,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 +499,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
@@ -175,7 +187,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?

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

@@ -101,7 +101,7 @@ 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

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

@@ -75,6 +75,7 @@ module RuboCop
           check_for_breakable_block(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_str(node)
           check_for_breakable_str(node)
@@ -92,6 +93,7 @@ module RuboCop
         alias on_send on_potential_breakable_node
         alias on_csend on_potential_breakable_node
         alias on_def on_potential_breakable_node
+        alias on_defs on_potential_breakable_node
 
         def on_new_investigation
           return unless processed_source.raw_source.include?(';')
@@ -132,6 +134,7 @@ module RuboCop
 
         def check_for_breakable_block(block_node)
           return unless block_node.single_line?
+          return if receiver_contains_heredoc?(block_node)
 
           line_index = block_node.loc.line - 1
           range = breakable_block_range(block_node)
@@ -209,7 +212,7 @@ module RuboCop
         # are not bisected.
         # If the string contains spaces, use them to determine a place for a clean break;
         # otherwise, the string will be broken at the line length limit.
-        def breakable_string_range(node) # rubocop:disable Metrics/AbcSize
+        def breakable_string_range(node)
           source_range = node.source_range
           relevant_substr = largest_possible_string(node)
 
@@ -221,13 +224,13 @@ module RuboCop
             adjustment = max - source_range.last_column - 3
             return if adjustment.abs > source_range.size
 
-            source_range.adjust(end_pos: max - source_range.last_column - 3)
+            source_range.adjust(end_pos: adjustment)
           end
         end
 
         def breakable_dstr_begin_position(node)
           source_range = node.source_range
-          source_range.begin_pos if source_range.begin_pos < max && source_range.end_pos >= max
+          source_range.begin_pos if source_range.column < max && source_range.last_column >= max
         end
 
         def breakable_range_by_line_index
@@ -249,17 +252,22 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
+          if allow_rbs_inline_annotation? && rbs_inline_annotation_on_source_line?(line_index)
+            return
+          end
 
-          if ignore_cop_directives? && directive_on_source_line?(line_index)
+          if allow_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
-          return check_uri_line(line, line_index) if allow_uri?
+          return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||
@@ -303,6 +311,7 @@ module RuboCop
         def max
           cop_config['Max']
         end
+        alias max_line_length max
 
         def allow_heredoc?
           allowed_heredoc
@@ -319,7 +328,7 @@ module RuboCop
         def extract_heredocs(ast)
           return [] unless ast
 
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+          ast.each_node(:any_str).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
             delimiter = node.location.heredoc_end.source.strip
             [body.first_line...body.last_line, delimiter]
@@ -339,6 +348,13 @@ module RuboCop
           heredocs.any? { |range, _delimiter| range.cover?(line_number) }
         end
 
+        def receiver_contains_heredoc?(node)
+          return false unless (receiver = node.receiver)
+          return true if receiver.any_str_type? && receiver.heredoc?
+
+          receiver.each_descendant(:any_str).any?(&:heredoc?)
+        end
+
         def check_directive_line(line, line_index)
           length_without_directive = line_length_without_directive(line)
           return if length_without_directive <= max
@@ -356,11 +372,32 @@ module RuboCop
           )
         end
 
-        def check_uri_line(line, line_index)
-          uri_range = find_excessive_uri_range(line)
-          return if uri_range && allowed_uri_position?(line, uri_range)
+        def check_line_for_exemptions(line, line_index)
+          uri_range            = range_if_applicable(line, :uri)
+          qualified_name_range = range_if_applicable(line, :qualified_name)
+
+          return if allowed_combination?(line, uri_range, qualified_name_range)
+
+          range = uri_range || qualified_name_range
+          register_offense(excess_range(range, line, line_index), line, line_index)
+        end
+
+        def range_if_applicable(line, type)
+          return unless type == :uri ? allow_uri? : allow_qualified_name?
 
-          register_offense(excess_range(uri_range, line, line_index), line, line_index)
+          find_excessive_range(line, type)
+        end
+
+        def allowed_combination?(line, uri_range, qualified_name_range)
+          if uri_range && qualified_name_range
+            allowed_position?(line, uri_range) && allowed_position?(line, qualified_name_range)
+          elsif uri_range
+            allowed_position?(line, uri_range)
+          elsif qualified_name_range
+            allowed_position?(line, qualified_name_range)
+          else
+            false
+          end
         end
 
         def breakable_dstr?(node)
@@ -369,9 +406,11 @@ module RuboCop
         end
 
         def string_delimiter(node)
-          delimiter = node.loc.begin
-          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type?
-          delimiter = delimiter&.source
+          delimiter = if node.loc?(:begin)
+                        node.loc.begin
+                      elsif node.parent&.dstr_type? && node.parent.loc?(:begin)
+                        node.parent.loc.begin
+                      end&.source
 
           delimiter if %w[' "].include?(delimiter)
         end
@@ -381,8 +420,16 @@ module RuboCop
           # The maximum allowed length of a string value is:
           # `Max` - end delimiter (quote) - continuation characters (space and slash)
           max_length = max - 3
-          # If the string doesn't start at the beginning of the line, the max length is offset
-          max_length -= column_offset_between(node.loc, node.parent.loc) if node.parent
+          # Offset by the string's starting column so the broken line actually fits
+          # within `Max`. When on the same line as its parent, use the column difference;
+          # otherwise the string is indented on its own line, so subtract that indentation.
+          # (Without this, an indented string under a multi-line parent never shortens
+          # below `Max` and the autocorrect loops, inserting empty `"" \` fragments.)
+          max_length -= if same_line?(node, node.parent)
+                          column_offset_between(node.loc, node.parent.loc)
+                        else
+                          node.loc.column
+                        end
           node.source[0...(max_length)]
         end
       end

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

@@ -27,67 +27,67 @@ module RuboCop
       # line as the last element of the array.
       #
       # @example EnforcedStyle: symmetrical (default)
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: new_line
-      #     # bad
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # bad
-      #     [ :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b
-      #     ]
+      #   # bad
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # bad
+      #   [ :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b
+      #   ]
       #
       # @example EnforcedStyle: same_line
-      #     # bad
-      #     [ :a,
-      #       :b
-      #     ]
-      #
-      #     # bad
-      #     [
-      #       :a,
-      #       :b
-      #     ]
-      #
-      #     # good
-      #     [
-      #       :a,
-      #       :b ]
-      #
-      #     # good
-      #     [ :a,
-      #       :b ]
+      #   # bad
+      #   [ :a,
+      #     :b
+      #   ]
+      #
+      #   # bad
+      #   [
+      #     :a,
+      #     :b
+      #   ]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b ]
+      #
+      #   # good
+      #   [ :a,
+      #     :b ]
       class MultilineArrayBraceLayout < Base
         include MultilineLiteralBraceLayout
         extend AutoCorrector