rubocop 1.79.2 → 1.88.0

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

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

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

@@ -69,14 +69,18 @@ module RuboCop
         SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
                             'on the same line as the assignment operator `=`.'
 
+        BLOCK_TYPES = %i[block numblock itblock].freeze
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_assignment(node, rhs)
           return if node.send_type? && node.loc.operator&.source != '='
           return unless rhs
           return unless supported_types.include?(rhs.type)
-          return if rhs.single_line?
+          return if rhs.single_line? && (!rhs.block_type? || same_line?(node, rhs.loc.begin))
 
           check_by_enforced_style(node, rhs)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_by_enforced_style(node, rhs)
           case style
@@ -109,7 +113,10 @@ module RuboCop
         private
 
         def supported_types
-          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+          @supported_types ||= cop_config['SupportedTypes'].flat_map do |type|
+            sym = type.to_sym
+            sym == :block ? BLOCK_TYPES : sym
+          end
         end
       end
     end

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

@@ -78,6 +78,8 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
+          return false unless max_line_length
+
           needed_length_for_args(node) > max_line_length
         end