rubocop 1.82.1 → 1.84.0

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,12 +100,11 @@ module RuboCop
 
           return unless begins_its_line?(end_loc)
 
-          # For blocks where the dot is on a new line, use the dot position as the base.
-          # Otherwise, use the end keyword position as the base.
-          base_loc = dot_on_new_line?(node) ? node.send_node.loc.dot : end_loc
+          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
@@ -148,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
 
@@ -167,6 +183,8 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
+          return unless node
+
           AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
         end
 
@@ -175,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)
@@ -304,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
@@ -363,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
@@ -377,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)
@@ -387,6 +472,14 @@ module RuboCop
           leftmost_modifier_of(node.parent)
         end
 
+        def block_body_indentation_base(node, end_loc)
+          if style != :relative_to_receiver || !dot_on_new_line?(node)
+            end_loc
+          else
+            node.send_node.loc.dot
+          end
+        end
+
         def dot_on_new_line?(node)
           send_node = node.send_node
           return false unless send_node.loc?(:dot)

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

@@ -418,8 +418,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_hash_brace_layout.rb

@@ -28,66 +28,66 @@ module RuboCop
       #
       # @example EnforcedStyle: symmetrical (default)
       #
-      #     # bad
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
+      #   # bad
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
       #
       # @example EnforcedStyle: new_line
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # bad
-      #     { a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # bad
+      #   { a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
       #
       # @example EnforcedStyle: same_line
-      #     # bad
-      #     { a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # bad
-      #     {
-      #       a: 1,
-      #       b: 2
-      #     }
-      #
-      #     # good
-      #     {
-      #       a: 1,
-      #       b: 2 }
-      #
-      #     # good
-      #     { a: 1,
-      #       b: 2 }
+      #   # bad
+      #   { a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # bad
+      #   {
+      #     a: 1,
+      #     b: 2
+      #   }
+      #
+      #   # good
+      #   {
+      #     a: 1,
+      #     b: 2 }
+      #
+      #   # good
+      #   { a: 1,
+      #     b: 2 }
       class MultilineHashBraceLayout < Base
         include MultilineLiteralBraceLayout
         extend AutoCorrector

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

@@ -7,18 +7,18 @@ module RuboCop
       # parenthesis (`(`) in lambda literals.
       #
       # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
+      #   # bad
+      #   a = -> (x, y) { x + y }
       #
-      #     # good
-      #     a = ->(x, y) { x + y }
+      #   # good
+      #   a = ->(x, y) { x + y }
       #
       # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
+      #   # bad
+      #   a = ->(x, y) { x + y }
       #
-      #     # good
-      #     a = -> (x, y) { x + y }
+      #   # good
+      #   a = -> (x, y) { x + y }
       class SpaceInLambdaLiteral < Base
         include ConfigurableEnforcedStyle
         include RangeHelp

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -56,6 +56,27 @@ module RuboCop
       #     1
       #   end
       #
+      #   # bad
+      #   class MyClass
+      #     extend Forwardable
+      #
+      #     # or with: `def_instance_delegator`, `def_delegators`, `def_instance_delegators`
+      #     def_delegator :delegation_target, :delegated_method_name
+      #
+      #     def delegated_method_name
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #     extend Forwardable
+      #
+      #     def_delegator :delegation_target, :delegated_method_name
+      #
+      #     def non_duplicated_delegated_method_name
+      #     end
+      #   end
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
@@ -97,10 +118,11 @@ module RuboCop
       #     delegate :foo, to: :bar
       #   end
       #
-      class DuplicateMethods < Base
+      class DuplicateMethods < Base # rubocop:disable Metrics/ClassLength
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
         RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr
-                              delegate].freeze
+                              delegate def_delegator def_instance_delegator def_delegators
+                              def_instance_delegators].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -154,23 +176,49 @@ module RuboCop
           )
         PATTERN
 
+        # @!method delegator?(node)
+        def_node_matcher :delegator?, <<~PATTERN
+          (send nil? {:def_delegator :def_instance_delegator}
+            {
+              {sym str} ({sym str} $_) |
+              {sym str} {sym str} ({sym str} $_)
+            }
+          )
+        PATTERN
+
+        # @!method delegators?(node)
+        def_node_matcher :delegators?, <<~PATTERN
+          (send nil? {:def_delegators :def_instance_delegators}
+            {sym str}
+            ({sym str} $_)+
+          )
+        PATTERN
+
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
-        def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def on_send(node) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           name, original_name = alias_method?(node)
 
           if name && original_name
             return if name == original_name
-            return if node.ancestors.any?(&:if_type?)
+            return if inside_condition?(node)
 
             found_instance_method(node, name)
           elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           elsif active_support_extensions_enabled? && (names = delegate_method?(node))
-            return if node.ancestors.any?(&:if_type?)
+            return if inside_condition?(node)
 
             on_delegate(node, names)
+          elsif (name = delegator?(node))
+            return if inside_condition?(node)
+
+            found_instance_method(node, name)
+          elsif (names = delegators?(node))
+            return if inside_condition?(node)
+
+            names.each { |name| found_instance_method(node, name) }
           end
         end
 
@@ -190,6 +238,10 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
+        def inside_condition?(node)
+          node.ancestors.any?(&:if_type?)
+        end
+
         def message_for_dup(node, method_name, key)
           format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -77,7 +77,7 @@ module RuboCop
 
         def on_case(node)
           node.when_branches.each do |when_branch|
-            when_branch.each_condition do |condition|
+            when_branch.conditions.each do |condition|
               next if !float?(condition) || literal_safe?(condition)
 
               add_offense(condition, message: MSG_CASE)

data/lib/rubocop/cop/lint/literal_as_condition.rb

@@ -157,7 +157,7 @@ module RuboCop
 
             check_case(case_match_node)
           else
-            case_match_node.each_in_pattern do |in_pattern_node|
+            case_match_node.in_pattern_branches.each do |in_pattern_node|
               next unless in_pattern_node.condition.literal?
 
               add_offense(in_pattern_node)

data/lib/rubocop/cop/lint/redundant_splat_expansion.rb

@@ -77,7 +77,7 @@ module RuboCop
         PERCENT_CAPITAL_W = '%W'
         PERCENT_I = '%i'
         PERCENT_CAPITAL_I = '%I'
-        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
         # @!method array_new?(node)
         def_node_matcher :array_new?, <<~PATTERN

data/lib/rubocop/cop/lint/struct_new_override.rb

@@ -26,7 +26,23 @@ module RuboCop
               'and it may be unexpected.'
         RESTRICT_ON_SEND = %i[new].freeze
 
-        STRUCT_METHOD_NAMES = Struct.instance_methods
+        # This is based on `Struct.instance_methods.sort` in Ruby 4.0.0.
+        STRUCT_METHOD_NAMES = %i[
+          ! != !~ <=> == === [] []= __id__ __send__ all? any? chain chunk chunk_while class clone
+          collect collect_concat compact count cycle deconstruct deconstruct_keys
+          define_singleton_method detect dig display drop drop_while dup each each_cons each_entry
+          each_pair each_slice each_with_index each_with_object entries enum_for eql? equal? extend
+          filter filter_map find find_all find_index first flat_map freeze frozen? grep grep_v
+          group_by hash include? inject inspect instance_eval instance_exec instance_of?
+          instance_variable_defined? instance_variable_get instance_variable_set instance_variables
+          is_a? itself kind_of? lazy length map max max_by member? members method methods
+          min min_by minmax minmax_by nil? none? object_id one? partition private_methods
+          protected_methods public_method public_methods public_send reduce reject
+          remove_instance_variable respond_to? reverse_each select send singleton_class
+          singleton_method singleton_methods size slice_after slice_before slice_when sort sort_by
+          sum take take_while tally tap then to_a to_enum to_h to_s to_set uniq values values_at
+          yield_self zip
+        ].freeze
         STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
 
         # @!method struct_new(node)

data/lib/rubocop/cop/lint/to_json.rb

@@ -5,27 +5,23 @@ module RuboCop
     module Lint
       # Checks to make sure `#to_json` includes an optional argument.
       # When overriding `#to_json`, callers may invoke JSON
-      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows
       # for an optional argument, your method should too.
       #
       # @example
-      #   class Point
-      #     attr_reader :x, :y
-      #
-      #     # bad, incorrect arity
-      #     def to_json
-      #       JSON.generate([x, y])
-      #     end
+      #   # bad - incorrect arity
+      #   def to_json
+      #     JSON.generate([x, y])
+      #   end
       #
-      #     # good, preserving args
-      #     def to_json(*args)
-      #       JSON.generate([x, y], *args)
-      #     end
+      #   # good - preserving args
+      #   def to_json(*args)
+      #     JSON.generate([x, y], *args)
+      #   end
       #
-      #     # good, discarding args
-      #     def to_json(*_args)
-      #       JSON.generate([x, y])
-      #     end
+      #   # good - discarding args
+      #   def to_json(*_args)
+      #     JSON.generate([x, y])
       #   end
       #
       class ToJSON < Base