rubocop 1.79.2 → 1.87.0

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,56 @@ 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
+        # @!method class_or_module_new_block?(node)
+        def_node_matcher :class_or_module_new_block?, <<~PATTERN
+          (block
+            (send (const _ {:Class :Module}) :new ...)
+            ...)
+        PATTERN
+
+        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
 
@@ -185,9 +240,16 @@ module RuboCop
 
         def check_self_receiver(node, name)
           enclosing = node.parent_module_name
-          return unless enclosing
+          if enclosing
+            found_method(node, "#{enclosing}.#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            scope = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            found_method(node, "#{scope}.#{name}", scope_id: anon_block_scope_id(anon_block))
+          end
+        end
 
-          found_method(node, "#{enclosing}.#{name}")
+        def inside_condition?(node)
+          node.ancestors.any?(&:if_type?)
         end
 
         def message_for_dup(node, method_name, key)
@@ -222,16 +284,50 @@ module RuboCop
         end
 
         def found_instance_method(node, name)
-          return found_sclass_method(node, name) unless (scope = node.parent_module_name)
+          if (scope = node.parent_module_name)
+            found_method(node, "#{humanize_scope(scope)}#{name}")
+          elsif (anon_block = anonymous_class_block(node))
+            base = qualified_name(anon_block.parent_module_name, nil, 'Object')
+            scope = node.each_ancestor(:sclass).any? ? "#<Class:#{base}>" : base
+            found_method(
+              node, "#{humanize_scope(scope)}#{name}", scope_id: anon_block_scope_id(anon_block)
+            )
+          else
+            found_sclass_method(node, name)
+          end
+        end
 
-          # Humanize the scope
+        def humanize_scope(scope)
           scope = scope.sub(
             /(?:(?<name>.*)::)#<Class:\k<name>>|#<Class:(?<name>.*)>(?:::)?/,
             '\k<name>.'
           )
-          scope << '#' unless scope.end_with?('.')
+          scope.end_with?('.') ? scope : "#{scope}#"
+        end
+
+        def anonymous_class_block(node)
+          first_block = node.each_ancestor(:block).first
+          return unless class_or_module_new_block?(first_block)
+          return if first_block.parent&.type?(:lvasgn)
+          return if node.each_ancestor(:sclass).any? { |s| !s.children.first.self_type? }
+
+          first_block
+        end
+
+        def anon_block_scope_id(anon_block)
+          parent = anon_block.parent
+          return unless parent&.type?(:any_block, :begin, :call, :casgn, :any_def)
+
+          if (receiver = named_receiver(parent))
+            "#{receiver.source}.#{parent.method_name}"
+          elsif !parent.begin_type? || parent.parent&.any_block_type?
+            source_location(anon_block)
+          end
+        end
 
-          found_method(node, "#{scope}#{name}")
+        def named_receiver(node)
+          receiver = node.receiver
+          receiver unless class_or_module_new_block?(receiver)
         end
 
         def found_sclass_method(node, name)
@@ -244,8 +340,10 @@ module RuboCop
           found_method(node, "#{singleton_receiver_node.method_name}.#{name}")
         end
 
-        def found_method(node, method_name)
+        # rubocop:disable Metrics/AbcSize
+        def found_method(node, method_name, scope_id: nil)
           key = method_key(node, method_name)
+          key = "#{key}@#{scope_id}" if scope_id
           scope = node.each_ancestor(:rescue, :ensure).first&.type
 
           if @definitions.key?(key)
@@ -262,6 +360,7 @@ module RuboCop
             @definitions[key] = node
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def method_key(node, method_name)
           if (ancestor_def = node.each_ancestor(:any_def).first)

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

@@ -24,8 +24,6 @@ module RuboCop
 
         MSG_REPEATED_ELEMENT = 'Duplicate element inside regexp character class'
 
-        OCTAL_DIGITS_AFTER_ESCAPE = 2
-
         def on_regexp(node)
           each_repeated_character_class_element_loc(node) do |loc|
             add_offense(loc, message: MSG_REPEATED_ELEMENT) do |corrector|
@@ -40,9 +38,9 @@ module RuboCop
 
             seen = Set.new
             group_expressions(node, expr.expressions) do |group|
-              group_source = group.map(&:to_s).join
+              group_source = group.to_s
 
-              yield source_range(group) if seen.include?(group_source)
+              yield group.expression if seen.include?(group_source)
 
               seen << group_source
             end
@@ -52,40 +50,13 @@ module RuboCop
         private
 
         def group_expressions(node, expressions)
-          # Create a mutable list to simplify state tracking while we iterate.
-          expressions = expressions.to_a
-
-          until expressions.empty?
-            # With we may need to compose a group of multiple expressions.
-            group = [expressions.shift]
-            next if within_interpolation?(node, group.first)
-
-            # With regexp_parser < 2.7 escaped octal sequences may be up to 3
-            # separate expressions ("\\0", "0", "1").
-            pop_octal_digits(group, expressions) if escaped_octal?(group.first.to_s)
-
-            yield(group)
-          end
-        end
-
-        def pop_octal_digits(current_child, expressions)
-          OCTAL_DIGITS_AFTER_ESCAPE.times do
-            next_child = expressions.first
-            break unless octal?(next_child.to_s)
+          expressions.each do |expression|
+            next if within_interpolation?(node, expression)
 
-            current_child << expressions.shift
+            yield(expression)
           end
         end
 
-        def source_range(children)
-          return children.first.expression if children.size == 1
-
-          range_between(
-            children.first.expression.begin_pos,
-            children.last.expression.begin_pos + children.last.to_s.length
-          )
-        end
-
         def skip_expression?(expr)
           expr.type != :set || expr.token == :intersection
         end
@@ -99,14 +70,6 @@ module RuboCop
           interpolation_locs(node).any? { |il| il.overlaps?(parse_tree_child_loc) }
         end
 
-        def escaped_octal?(string)
-          string.length == 2 && string[0] == '\\' && octal?(string[1])
-        end
-
-        def octal?(char)
-          ('0'..'7').cover?(char)
-        end
-
         def interpolation_locs(node)
           @interpolation_locs ||= {}
 

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

@@ -38,6 +38,24 @@ module RuboCop
       #   elsif do_this
       #     do_that
       #   end
+      #
+      #   # bad
+      #
+      #   # For single-line conditionals using `then` the layout is disallowed
+      #   # when the `else` body is multiline because it is treated as a lint offense.
+      #   if something then on_the_same_line_as_then
+      #   else first_line
+      #     second_line
+      #   end
+      #
+      #   # good
+      #
+      #   # For single-line conditional using `then` the layout is allowed
+      #   # when `else` body is a single-line because it is treated as intentional.
+      #
+      #   if something then on_the_same_line_as_then
+      #   else single_line
+      #   end
       class ElseLayout < Base
         include Alignment
         include RangeHelp
@@ -47,6 +65,7 @@ module RuboCop
 
         def on_if(node)
           return if node.ternary?
+          return if node.then? && !node.else_branch&.begin_type?
 
           # If the if is on a single line, it'll be handled by `Style/OneLineConditional`
           return if node.single_line?

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

@@ -63,7 +63,7 @@ module RuboCop
       class EmptyBlock < Base
         MSG = 'Empty block detected.'
 
-        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           return if node.body
           return if allow_empty_lambdas? && node.lambda_or_proc?
           return if cop_config['AllowComments'] && allow_comment?(node)

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

@@ -70,7 +70,7 @@ module RuboCop
 
         def on_if(node)
           return if node.body || same_line?(node.loc.begin, node.loc.end)
-          return if cop_config['AllowComments'] && contains_comments?(node)
+          return if allow_comments?(node)
 
           range = offense_range(node)
 
@@ -83,6 +83,11 @@ module RuboCop
 
         private
 
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
+
         def offense_range(node)
           if node.loc.else
             node.source_range.begin.join(node.loc.else.begin)

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

@@ -53,11 +53,18 @@ module RuboCop
         def on_case_match(node)
           node.in_pattern_branches.each do |branch|
             next if branch.body
-            next if cop_config['AllowComments'] && contains_comments?(branch)
+            next if allow_comments?(branch)
 
             add_offense(branch)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

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

@@ -19,12 +19,23 @@ module RuboCop
         MSG = 'Empty interpolation detected.'
 
         def on_interpolation(begin_node)
+          return if in_percent_literal_array?(begin_node)
+
           node_children = begin_node.children.dup
           node_children.delete_if { |e| e.nil_type? || (e.basic_literal? && e.str_content&.empty?) }
           return unless node_children.empty?
 
           add_offense(begin_node) { |corrector| corrector.remove(begin_node) }
         end
+
+        private
+
+        def in_percent_literal_array?(begin_node)
+          array_node = begin_node.each_ancestor(:array).first
+          return false unless array_node
+
+          array_node.percent_literal?
+        end
       end
     end
   end

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

@@ -50,11 +50,18 @@ module RuboCop
         def on_case(node)
           node.when_branches.each do |when_node|
             next if when_node.body
-            next if cop_config['AllowComments'] && contains_comments?(when_node)
+            next if allow_comments?(when_node)
 
             add_offense(when_node)
           end
         end
+
+        private
+
+        def allow_comments?(node)
+          cop_config['AllowComments'] && contains_comments?(node) &&
+            !comments_contain_disables?(node, name)
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
       # `ERB.new` with non-keyword arguments is deprecated since ERB 2.2.0.
       # Use `:trim_mode` and `:eoutvar` keyword arguments to `ERB.new`.
       # This cop identifies places where `ERB.new(str, trim_mode, eoutvar)` can
-      # be replaced by `ERB.new(str, :trim_mode: trim_mode, eoutvar: eoutvar)`.
+      # be replaced by `ERB.new(str, trim_mode: trim_mode, eoutvar: eoutvar)`.
       #
       # @example
       #   # Target codes supports Ruby 2.6 and higher only

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/interpolation_check.rb

@@ -54,9 +54,14 @@ module RuboCop
         end
 
         def valid_syntax?(node)
-          double_quoted_string = node.source.gsub(/\A'|'\z/, '"')
+          double_quoted_string = if node.source.include?('"')
+                                   node.source.sub(/\A'/, '%{').sub(/'\z/, '}')
+                                 else
+                                   node.source.gsub(/\A'|'\z/, '"')
+                                 end
 
-          parse(double_quoted_string).valid_syntax?
+          processed_source = parse(double_quoted_string)
+          processed_source.valid_syntax? && processed_source.ast.dstr_type?
         end
       end
     end

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)
@@ -269,7 +269,11 @@ module RuboCop
                      end
 
           add_offense(cond) do |corrector|
+            next if part_of_ignored_node?(node)
+
             corrector.replace(node, new_node)
+
+            ignore_node(node)
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def special_keyword?(node)
           # handle strings like __FILE__
-          (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
+          (node.str_type? && !node.loc?(:begin)) || node.source_range.is?('__LINE__')
         end
 
         def array_in_regexp?(node)

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

@@ -6,12 +6,24 @@ module RuboCop
     module Lint
       # Checks that there is an `# rubocop:enable ...` statement
       # after a `# rubocop:disable ...` statement. This will prevent leaving
-      # cop disables on wide ranges of code, that latter contributors to
+      # cop disables on wide ranges of code, that later contributors to
       # a file wouldn't be aware of.
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: .inf
+      # You can set `MaximumRangeSize` to define the maximum number of
+      # consecutive lines a cop can be disabled for.
+      #
+      # - `.inf` any size (default)
+      # - `0` allows only single-line disables
+      # - `1` means the maximum allowed is as follows:
+      #
+      # [source,ruby]
+      # ----
+      # # rubocop:disable SomeCop
+      # a = 1
+      # # rubocop:enable SomeCop
+      # ----
+      #
+      # @example MaximumRangeSize: .inf (default)
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -25,9 +37,7 @@ module RuboCop
       #   x= 0
       #   # EOF
       #
-      # @example
-      #   # Lint/MissingCopEnableDirective:
-      #   #   MaximumRangeSize: 2
+      # @example MaximumRangeSize: 2
       #
       #   # good
       #   # rubocop:disable Layout/SpaceAroundOperators
@@ -52,10 +62,9 @@ module RuboCop
           each_missing_enable do |cop, line_range|
             next if acceptable_range?(cop, line_range)
 
-            range = source_range(processed_source.buffer, line_range.min, 0..0)
             comment = processed_source.comment_at_line(line_range.begin)
 
-            add_offense(range, message: message(cop, comment))
+            add_offense(comment, message: message(cop, comment))
           end
         end
 

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

@@ -4,8 +4,8 @@ module RuboCop
   module Cop
     module Lint
       # In math and Python, we can use `x < y < z` style comparison to compare
-      # multiple value. However, we can't use the comparison in Ruby. However,
-      # the comparison is not syntax error. This cop checks the bad usage of
+      # multiple values. However, we can't use the comparison in Ruby. However,
+      # the comparison is not a syntax error. This cop checks the bad usage of
       # comparison operators.
       #
       # @example

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

@@ -31,6 +31,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -39,6 +40,7 @@ module RuboCop
           {
             (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
             (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+            (itblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
           }
         PATTERN
 

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

@@ -45,6 +45,10 @@ module RuboCop
             end
           end
         end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+        alias on_casgn on_lvasgn
         alias on_or_asgn on_lvasgn
         alias on_op_asgn on_lvasgn
       end

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

@@ -12,7 +12,7 @@ module RuboCop
       # always sort the list.
       #
       # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
-      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      # So all bad cases are acceptable when Ruby 3.0 or higher is used.
       #
       # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
       #
@@ -65,7 +65,9 @@ module RuboCop
 
         maximum_target_ruby_version 2.7
 
-        def on_block(node)
+        # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
+        # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # Warns the usage of unsafe number conversions. Unsafe
-      # number conversion can cause unexpected error if auto type conversion
-      # fails. Cop prefer parsing with number class instead.
+      # Warns against the usage of unsafe number conversions. Unsafe
+      # number conversion can cause an unexpected error if auto type conversion
+      # fails. The cop prefers parsing with a number class instead.
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
@@ -14,10 +14,10 @@ module RuboCop
       # always correct to raise if a value is not numeric.
       #
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
-      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # methods (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be allowed with `AllowedMethods`. By default,
-      # there are no methods to allowed.
+      # there are no allowed methods.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -162,7 +162,7 @@ module RuboCop
         end
 
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true

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

@@ -16,7 +16,7 @@ module RuboCop
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #
-      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # NOTE: The numbered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
       # as well to prevent confusion.
       #
       # @example

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

@@ -63,19 +63,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)