rubocop 1.79.2 → 1.87.0

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

@@ -172,7 +172,40 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+          return unless node
+
+          send_node = node.parent
+          return unless send_node
+
+          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
+
+          AlignmentCorrector.correct(corrector, processed_source, node_to_correct, column_delta)
+        end
+
+        def should_correct_entire_chain?(send_node, top_level_send)
+          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
+
+          top_level_send != send_node || begins_its_line?(top_level_send.loc.end)
+        end
+
+        def inner_call?(top_level_send)
+          outer_call = top_level_send.parent
+
+          outer_call&.send_type? && outer_call.parenthesized?
+        end
+
+        def find_top_level_send(send_node)
+          top_level_send = send_node
+          while top_level_send.parent&.send_type? &&
+                top_level_send.parent.receiver == top_level_send &&
+                top_level_send.parent.loc.dot
+            top_level_send = top_level_send.parent
+          end
+          top_level_send
         end
 
         def bare_operator?(node)

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

@@ -20,6 +20,27 @@ module RuboCop
       #   # good
       #   [:a, :b]
       #
+      # @example AllowImplicitArrayLiterals: false (default)
+      #
+      #   # bad
+      #   a = b,
+      #       c
+      #
+      #   # good
+      #   a =
+      #     b,
+      #     c
+      #
+      # @example AllowImplicitArrayLiterals: true
+      #
+      #   # good
+      #   a = b,
+      #       c
+      #
+      #   a =
+      #     b,
+      #     c
+      #
       # @example AllowMultilineFinalElement: false (default)
       #
       #   # bad
@@ -48,6 +69,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?
 
           check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
         end
@@ -59,6 +81,10 @@ module RuboCop
           /\s*=\s*$/.match?(source)
         end
 
+        def allow_implicit_array_brackets?
+          !!cop_config['AllowImplicitArrayLiterals']
+        end
+
         def ignore_last_element?
           !!cop_config['AllowMultilineFinalElement']
         end

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

@@ -135,7 +135,13 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          line_range = if !node.is_a?(AST::Node) || node.value.first_line <= node.key.first_line
+                         node
+                       else
+                         processed_source.buffer.line_range(node.loc.line)
+                       end
+
+          AlignmentCorrector.correct(corrector, processed_source, line_range, @column_delta)
         end
 
         def brace_alignment_style

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

@@ -8,40 +8,40 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     { a: 1,
-      #       b: 2}
+      #   # bad
+      #   { a: 1,
+      #     b: 2}
       #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2 }
       #
-      #     # good
-      #     {
-      #       a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # good
+      #   {
+      #     a: 1, b: {
+      #     c: 3
+      #   }}
       #
       # @example AllowMultilineFinalElement: false (default)
       #
-      #     # bad
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # bad
+      #   { a: 1, b: {
+      #     c: 3
+      #   }}
       #
       # @example AllowMultilineFinalElement: true
       #
-      #     # bad
-      #     { a: 1,
-      #       b: {
-      #       c: 3
-      #     }}
+      #   # bad
+      #   { a: 1,
+      #     b: {
+      #     c: 3
+      #   }}
       #
-      #     # good
-      #     { a: 1, b: {
-      #       c: 3
-      #     }}
+      #   # good
+      #   { a: 1, b: {
+      #     c: 3
+      #   }}
       #
       class FirstHashElementLineBreak < Base
         include FirstElementLineBreak

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the keys, separators, and values of a multi-line hash
+      # Checks that the keys, separators, and values of a multi-line hash
       # literal are aligned according to configuration. The configuration
       # options are:
       #
@@ -193,7 +193,6 @@ module RuboCop
         SEPARATOR_ALIGNMENT_STYLES = %w[EnforcedColonStyle EnforcedHashRocketStyle].freeze
 
         def on_send(node)
-          return if double_splat?(node)
           return unless node.arguments?
 
           last_argument = node.last_argument
@@ -233,6 +232,8 @@ module RuboCop
         end
 
         def argument_before_hash(hash_node)
+          return hash_node.children.first.children.first if hash_node.children.first.kwsplat_type?
+
           hash_node.left_sibling.respond_to?(:loc) ? hash_node.left_sibling : nil
         end
 
@@ -241,10 +242,6 @@ module RuboCop
           self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
         end
 
-        def double_splat?(node)
-          node.children.last.is_a?(Symbol)
-        end
-
         def check_pairs(node)
           first_pair = node.pairs.first
           reset!

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

@@ -168,7 +168,7 @@ module RuboCop
 
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
-          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+          return false unless last_arg_of_outer_send&.loc?(:end) &&
                               (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
 
           end_of_outer_send = outermost_send.loc.end
@@ -230,7 +230,7 @@ module RuboCop
 
         def find_most_bottom_of_heredoc_end(arguments)
           arguments.filter_map do |argument|
-            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+            argument.loc.heredoc_end.end_pos if argument.loc?(:heredoc_end)
           end.max
         end
 

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.
       #
@@ -41,7 +43,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 +67,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
@@ -83,9 +100,11 @@ module RuboCop
 
           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
@@ -145,7 +164,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
 
@@ -164,6 +183,8 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          return unless node
+
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
 
@@ -172,7 +193,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)
@@ -301,10 +322,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
@@ -360,7 +403,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
@@ -374,8 +423,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)
@@ -383,6 +471,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/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

@@ -134,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)
@@ -251,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_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) ||
@@ -305,6 +311,7 @@ module RuboCop
         def max
           cop_config['Max']
         end
+        alias max_line_length max
 
         def allow_heredoc?
           allowed_heredoc
@@ -321,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]
@@ -341,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
@@ -392,11 +406,11 @@ module RuboCop
         end
 
         def string_delimiter(node)
-          delimiter = node.loc.begin
-          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
-            delimiter ||= node.parent.loc.begin
-          end
-          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
@@ -406,8 +420,11 @@ 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
+          # If the string is on the same line as its parent, offset by the column difference
+          # (Only apply when on same line to avoid negative offsets for multi-line dstr)
+          if same_line?(node, node.parent)
+            max_length -= column_offset_between(node.loc, node.parent.loc)
+          end
           node.source[0...(max_length)]
         end
       end