rubocop 1.71.2 → 1.75.2

data/lib/rubocop/cop/metrics/block_length.rb

@@ -57,6 +57,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -63,6 +63,7 @@ module RuboCop
           check_code_length(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -145,7 +145,7 @@ module RuboCop
 
           def extract_body(node)
             case node.type
-            when :class, :module, :sclass, :block, :numblock, :def, :defs
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
               node.body
             when :casgn
               extract_body(node.expression)

data/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -26,6 +26,13 @@ module RuboCop
           extend NodePattern::Macros
           include RuboCop::AST::Sexp
 
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
           # Plug into the calculator
           def initialize(node, discount_repeated_attributes: false)
             super(node)
@@ -114,13 +121,6 @@ module RuboCop
             calls.fetch(value) { yield [calls, value] }
           end
 
-          VAR_SETTER_TO_GETTER = {
-            lvasgn: :lvar,
-            ivasgn: :ivar,
-            cvasgn: :cvar,
-            gvasgn: :gvar
-          }.freeze
-
           # @returns `[receiver, method | nil]` for the given setter `node`
           # or `nil` if it is not a setter.
           def setter_to_getter(node)

data/lib/rubocop/cop/mixin/alignment.rb

@@ -5,10 +5,10 @@ module RuboCop
     # This module checks for nodes that should be aligned to the left or right.
     # This amount is determined by the instance variable @column_delta.
     module Alignment
-      private
-
       SPACE = ' '
 
+      private
+
       attr_reader :column_delta
 
       def configured_indentation_width

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -18,12 +18,12 @@ module RuboCop
       end
 
       # @deprecated Use allowed_line? instead
-      def ignored_line?
+      def ignored_line?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `ignored_line?` is deprecated. Use `allowed_line?` instead.
         WARNING
 
-        allowed_line?
+        allowed_line?(line)
       end
 
       def matches_allowed_pattern?(line)
@@ -31,12 +31,12 @@ module RuboCop
       end
 
       # @deprecated Use matches_allowed_pattern? instead
-      def matches_ignored_pattern?
+      def matches_ignored_pattern?(line)
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
         WARNING
 
-        matches_allowed_pattern?
+        matches_allowed_pattern?(line)
       end
 
       def allowed_patterns

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -48,7 +48,7 @@ module RuboCop
 
           args = process_args(node.arguments)
           return extract_breakable_node_from_elements(node, args, max)
-        elsif node.def_type?
+        elsif node.any_def_type?
           return extract_breakable_node_from_elements(node, node.arguments, max)
         elsif node.type?(:array, :hash)
           return extract_breakable_node_from_elements(node, node.children, max)
@@ -220,7 +220,7 @@ module RuboCop
 
       # @api private
       def already_on_multiple_lines?(node)
-        return node.first_line != node.last_argument.last_line if node.def_type?
+        return node.first_line != node.last_argument.last_line if node.any_def_type?
 
         !node.single_line?
       end

data/lib/rubocop/cop/mixin/check_single_line_suitability.rb

@@ -35,12 +35,12 @@ module RuboCop
         comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
 
         comment_line_numbers.any? do |comment_line_number|
-          comment_line_number >= node.first_line && comment_line_number <= node.last_line
+          comment_line_number.between?(node.first_line, node.last_line)
         end
       end
 
       def safe_to_split?(node)
-        node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
+        node.each_descendant(:if, :case, :kwbegin, :any_def).none? &&
           node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
           node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
       end

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -82,7 +82,7 @@ module RuboCop
               next_sibling.source_range
           next_sibling.loc.line
         elsif (parent = node.parent)
-          if parent.loc.respond_to?(:end) && parent.loc.end
+          if parent.loc?(:end)
             parent.loc.end.line
           else
             parent.loc.line

data/lib/rubocop/cop/mixin/def_node.rb

@@ -19,7 +19,7 @@ module RuboCop
 
       # @!method non_public_modifier?(node)
       def_node_matcher :non_public_modifier?, <<~PATTERN
-        (send nil? {:private :protected :private_class_method} ({def defs} ...))
+        (send nil? {:private :protected :private_class_method} (any_def ...))
       PATTERN
     end
   end

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -21,7 +21,7 @@ module RuboCop
 
         # @!method empty_line_required?(node)
         def_node_matcher :empty_line_required?,
-                         '{def defs class module (send nil? {:private :protected :public})}'
+                         '{any_def class module (send nil? {:private :protected :public})}'
 
         def check(node, body, adjusted_first_line: nil)
           return if valid_body_style?(body)

data/lib/rubocop/cop/mixin/forbidden_identifiers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain identifiers in a cop.
+    module ForbiddenIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def forbidden_identifier?(name)
+        name = name.to_s.delete(SIGILS)
+
+        forbidden_identifiers.any? && forbidden_identifiers.include?(name)
+      end
+
+      def forbidden_identifiers
+        cop_config.fetch('ForbiddenIdentifiers', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to forbid certain patterns in a cop.
+    module ForbiddenPattern
+      def forbidden_pattern?(name)
+        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+      end
+
+      def forbidden_patterns
+        cop_config.fetch('ForbiddenPatterns', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -6,7 +6,6 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL_REGEXP = /#\s*frozen[-_]?string[-_]?literal:/i.freeze
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
 

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -11,6 +11,24 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -212,24 +230,6 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
-
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
-      end
     end
   end
   # rubocop:enable Metrics/ModuleLength

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -23,7 +23,7 @@ module RuboCop
           (call _ _)
           (args
             $(arg _key)
-            (arg _))
+            $(arg _))
           {
             $(send
               {(lvar _key) $_ _ | _ $_ (lvar _key)})
@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def extracts_hash_subset?(block)
-        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+        block_with_first_arg_check?(block) do |key_arg, value_arg, send_node, method|
           # Only consider methods that have one argument
           return false unless send_node.arguments.one?
 
@@ -76,15 +76,22 @@ module RuboCop
 
           case method
           when :include?, :exclude?
-            send_node.first_argument.source == key_arg.source
+            slices_key?(send_node, :first_argument, key_arg, value_arg)
           when :in?
-            send_node.receiver.source == key_arg.source
+            slices_key?(send_node, :receiver, key_arg, value_arg)
           else
             true
           end
         end
       end
 
+      def slices_key?(send_node, method, key_arg, value_arg)
+        return false if using_value_variable?(send_node, value_arg)
+
+        node = method == :receiver ? send_node.receiver : send_node.first_argument
+        node.source == key_arg.source
+      end
+
       def range_include?(send_node)
         # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
         # or first argument is a range, an offense should not be registered.
@@ -97,6 +104,14 @@ module RuboCop
         receiver.range_type?
       end
 
+      def using_value_variable?(send_node, value_arg)
+        # If the receiver of `include?` or `exclude?`, or the first argument of `in?` is the
+        # hash value block argument, an offense should not be registered.
+        # ie. `v.include?(k)` or `k.in?(v)`
+        (send_node.receiver.lvar_type? && send_node.receiver.name == value_arg.name) ||
+          (send_node.first_argument.lvar_type? && send_node.first_argument.name == value_arg.name)
+      end
+
       def supported_subset_method?(method)
         if active_support_extensions_enabled?
           ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -9,6 +9,80 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
       # @!method array_receiver?(node)
       def_node_matcher :array_receiver?, <<~PATTERN
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
@@ -113,80 +187,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-
-        def transformation_uses_both_args?
-          transforming_body_expr.descendants.include?(unchanged_body_expr)
-        end
-
-        def use_transformed_argname?
-          transforming_body_expr.each_descendant(:lvar).any? do |node|
-            node.source == transformed_argname.to_s
-          end
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -30,6 +30,7 @@ module RuboCop
       end
 
       alias on_numblock on_block
+      alias on_itblock on_block
 
       private
 

data/lib/rubocop/cop/mixin/percent_literal.rb

@@ -21,7 +21,7 @@ module RuboCop
       end
 
       def begin_source(node)
-        node.loc.begin.source if node.loc.respond_to?(:begin) && node.loc.begin
+        node.loc.begin.source if node.loc?(:begin)
       end
 
       def type(node)

data/lib/rubocop/cop/mixin/range_help.rb

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # Methods that calculate and return Parser::Source::Ranges
     module RangeHelp
-      private
-
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+      NOT_GIVEN = Module.new
+
+      private
 
       def source_range(source_buffer, line_number, column, length = 1)
         if column.is_a?(Range)
@@ -33,6 +34,18 @@ module RuboCop
         range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
       end
 
+      # A range containing the first to the last argument
+      # of a method call or method definition.
+      # def foo(a, b:)
+      #         ^^^^^
+      # bar(1, 2, 3, &blk)
+      #     ^^^^^^^^^^^^^
+      # baz { |x, y:, z:| }
+      #        ^^^^^^^^^
+      def arguments_range(node)
+        node.first_argument.source_range.join(node.last_argument.source_range)
+      end
+
       def range_between(start_pos, end_pos)
         Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
       end
@@ -51,7 +64,6 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
                                        whitespace: false, continuations: false,

data/lib/rubocop/cop/mixin/string_help.rb

@@ -10,7 +10,7 @@ module RuboCop
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
-        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return unless node.loc?(:begin)
         return if part_of_ignored_node?(node)
 
         if offense?(node)

data/lib/rubocop/cop/mixin/target_ruby_version.rb

@@ -29,7 +29,7 @@ module RuboCop
         min = required_minimum_ruby_version || 0
         max = required_maximum_ruby_version || Float::INFINITY
 
-        min <= version && max >= version
+        version.between?(min, max)
       end
     end
   end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     # Common methods shared by Style/TrailingCommaInArguments,
     # Style/TrailingCommaInArrayLiteral and Style/TrailingCommaInHashLiteral
+    # rubocop:disable Metrics/ModuleLength
     module TrailingComma
       include ConfigurableEnforcedStyle
       include RangeHelp
@@ -57,6 +58,8 @@ module RuboCop
           ', unless each item is on its own line'
         when :consistent_comma
           ', unless items are split onto multiple lines'
+        when :diff_comma
+          ', unless that item immediately precedes a newline'
         else
           ''
         end
@@ -68,6 +71,8 @@ module RuboCop
           multiline?(node) && no_elements_on_same_line?(node)
         when :consistent_comma
           multiline?(node) && !method_name_and_arguments_on_same_line?(node)
+        when :diff_comma
+          multiline?(node) && last_item_precedes_newline?(node)
         else
           false
         end
@@ -130,6 +135,12 @@ module RuboCop
         range1.last_line == range2.line
       end
 
+      def last_item_precedes_newline?(node)
+        after_last_item =
+          range_between(node.children.last.source_range.end_pos, node.loc.end.begin_pos)
+        after_last_item.source =~ /\A,?\s*\n/
+      end
+
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind.include?('array') ? 'an' : 'a'
@@ -205,5 +216,6 @@ module RuboCop
         false
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -14,10 +14,10 @@ module RuboCop
       # autocorrected.
       #
       # [NOTE]
-      # --
+      # ====
       # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
       # no offense will be registered until Ruby 3.4:
-
+      #
       # [source,ruby]
       # ----
       # def foo(&block)
@@ -25,7 +25,7 @@ module RuboCop
       #   block_method { bar(&block) }
       # end
       # ----
-      # --
+      # ====
       #
       # @example EnforcedStyle: anonymous (default)
       #

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -242,7 +242,7 @@ module RuboCop
         def find_definition(node)
           # Methods can be defined in a `def` or `defs`,
           # or dynamically via a `block` node.
-          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+          node.each_ancestor(:any_def, :block).each do |ancestor|
             method_node, method_name = method_definition?(ancestor)
             return [method_node, method_name] if method_node
           end