rubocop 1.80.2 → 1.86.1

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -97,8 +97,8 @@ module RuboCop
         if delimiters.first != delimiters.last
           # With different delimiters (eg. `[]`, `()`), if there are the same
           # number of each, escaping is not necessary
-          delimiter_counts = delimiters.each_with_object({}) do |delimiter, counts|
-            counts[delimiter] = content.count(delimiter)
+          delimiter_counts = delimiters.to_h do |delimiter|
+            [delimiter, content.count(delimiter)]
           end
 
           return content if delimiter_counts[delimiters.first] == delimiter_counts[delimiters.last]

data/lib/rubocop/cop/documentation.rb

@@ -55,10 +55,9 @@ module RuboCop
 
       # @api private
       def builtin?(cop_class)
-        # any custom method will do
-        return false unless (m = cop_class.instance_methods(false).first)
+        return false unless (name = cop_class.name)
 
-        path, _line = cop_class.instance_method(m).source_location
+        path, _line = Module.const_source_location(name)
         path.start_with?(__dir__)
       end
     end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -69,8 +69,7 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          dependency_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
+          dependency_declarations(processed_source.ast).each_cons(2) do |previous, current|
             next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)

data/lib/rubocop/cop/gemspec/require_mfa.rb

@@ -92,7 +92,7 @@ module RuboCop
           (str "true")
         PATTERN
 
-        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler
+        def on_block(node) # rubocop:disable Metrics/MethodLength, InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
           gem_specification(node) do |block_var|
             metadata_value = metadata(node)
             mfa_value = mfa_value(metadata_value)

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `RUBY_VERSION` constant is not used in gemspec.
-      # Using `RUBY_VERSION` is dangerous because value of the
+      # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
+      # Using `RUBY_VERSION` and `Ruby::VERSION` are dangerous because value of the
       # constant is determined by `rake release`.
       # It's possible to have dependency based on ruby version used
       # to execute `rake release` and not user's ruby version.
@@ -28,15 +28,20 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         include GemspecHelp
 
-        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+        MSG = 'Do not use `%<ruby_version>s` in gemspec file.'
 
         # @!method ruby_version?(node)
-        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, <<~PATTERN
+          {
+            (const {cbase nil?} :RUBY_VERSION)
+            (const (const {cbase nil?} :Ruby) :VERSION)
+          }
+        PATTERN
 
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
-          add_offense(node)
+          add_offense(node, message: format(MSG, ruby_version: node.source))
         end
 
         private

data/lib/rubocop/cop/internal_affairs/example_heredoc_delimiter.rb

@@ -9,15 +9,15 @@ module RuboCop
       # the delimiter.
       #
       # @example
-      #  # bad
-      #  expect_offense(<<~CODE)
-      #    example_ruby_code
-      #  CODE
+      #   # bad
+      #   expect_offense(<<~CODE)
+      #     example_ruby_code
+      #   CODE
       #
-      #  # good
-      #  expect_offense(<<~RUBY)
-      #    example_ruby_code
-      #  RUBY
+      #   # good
+      #   expect_offense(<<~RUBY)
+      #     example_ruby_code
+      #   RUBY
       class ExampleHeredocDelimiter < Base
         extend AutoCorrector
 

data/lib/rubocop/cop/internal_affairs/itblock_handler.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for missing `itblock` handlers. The blocks with the `it`
+      # parameter introduced in Ruby 3.4 are parsed with a node type of
+      # `itblock` instead of block. Cops that define `block` handlers
+      # need to define `itblock` handlers or disable this cop for them.
+      #
+      # @example
+      #
+      #   # bad
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias on_itblock on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     alias_method :on_itblock, :on_block
+      #   end
+      #
+      #   class BlockRelatedCop < Base
+      #     def on_block(node)
+      #     end
+      #
+      #     def on_itblock(node)
+      #     end
+      #   end
+      class ItblockHandler < Base
+        MSG = 'Define on_itblock to handle blocks with the `it` parameter.'
+
+        def on_def(node)
+          return unless block_handler?(node)
+          return unless node.parent
+
+          add_offense(node) unless itblock_handler?(node.parent)
+        end
+
+        private
+
+        # @!method block_handler?(node)
+        def_node_matcher :block_handler?, <<~PATTERN
+          (def :on_block (args (arg :node)) ...)
+        PATTERN
+
+        # @!method itblock_handler?(node)
+        def_node_matcher :itblock_handler?, <<~PATTERN
+          {
+            `(def :on_itblock (args (arg :node)) ...)
+            `(alias (sym :on_itblock) (sym :on_block))
+            `(send nil? :alias_method (sym :on_itblock) (sym :on_block))
+          }
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/location_exists.rb

@@ -9,6 +9,12 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   node.loc.respond_to?(:begin)
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
       #   node.loc.respond_to?(:begin) && node.loc.begin
       #
       #   # good
@@ -29,7 +35,16 @@ module RuboCop
       class LocationExists < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG = 'Use `node.loc?` instead of `loc.respond_to?`.'
+        MSG_CORRECTABLE = 'Use `%<replacement>s` instead of `%<source>s`.'
+        RESTRICT_ON_SEND = %i[respond_to?].freeze
+
+        # @!method loc_respond_to?(node)
+        def_node_matcher :loc_respond_to?, <<~PATTERN
+          (call
+            (call $_receiver :loc) :respond_to?
+            $(sym _location))
+        PATTERN
 
         # @!method replaceable_with_loc_is(node)
         def_node_matcher :replaceable_with_loc_is, <<~PATTERN
@@ -64,6 +79,15 @@ module RuboCop
           replace_with_loc(node) || replace_with_loc_is(node)
         end
 
+        def on_send(node)
+          return if ignored_node?(node.parent)
+
+          loc_respond_to?(node) do |receiver, location|
+            register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+          end
+        end
+        alias on_csend on_send
+
         private
 
         def replace_with_loc(node)
@@ -84,11 +108,13 @@ module RuboCop
         end
 
         def register_offense(node, replacement)
-          message = format(MSG, replacement: replacement, source: node.source)
+          message = format(MSG_CORRECTABLE, replacement: replacement, source: node.source)
 
           add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement)
           end
+
+          ignore_node(node)
         end
 
         def replacement(receiver, rest)

data/lib/rubocop/cop/internal_affairs/node_matcher_directive.rb

@@ -8,16 +8,16 @@ module RuboCop
       # method.
       #
       # @example
-      #  # bad
-      #  def_node_matcher :foo?, <<~PATTERN
-      #    ...
-      #  PATTERN
+      #   # bad
+      #   def_node_matcher :foo?, <<~PATTERN
+      #     ...
+      #   PATTERN
       #
-      #  # good
-      #  # @!method foo?(node)
-      #  def_node_matcher :foo?, <<~PATTERN
-      #    ...
-      #  PATTERN
+      #   # good
+      #   # @!method foo?(node)
+      #   def_node_matcher :foo?, <<~PATTERN
+      #     ...
+      #   PATTERN
       #
       class NodeMatcherDirective < Base
         extend AutoCorrector

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -7,7 +7,7 @@ module RuboCop
         # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
         #
         # Looks for sequences and subsequences where the first item is a `node_type` node,
-        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
         # node type).
         #
         # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`

data/lib/rubocop/cop/internal_affairs/node_pattern_groups.rb

@@ -30,6 +30,8 @@ module RuboCop
           any_block: %i[block numblock itblock],
           any_def: %i[def defs],
           any_match_pattern: %i[match_pattern match_pattern_p],
+          any_str: %i[str dstr xstr],
+          any_sym: %i[sym dsym],
           argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
           boolean: %i[true false],
           call: %i[send csend],
@@ -210,7 +212,7 @@ module RuboCop
         # A heredoc can be a `dstr` without interpolation, but if there is interpolation
         # there'll be a `begin` node, in which case, we cannot evaluate the pattern.
         def acceptable_heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc? && node.each_child_node(:begin).none?
+          node.any_str_type? && node.heredoc? && node.each_child_node(:begin).none?
         end
 
         def process_pattern(pattern_node)

data/lib/rubocop/cop/internal_affairs/on_send_without_on_csend.rb

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
-          new_identifier = node.first_argument
+          return unless (new_identifier = node.first_argument)
           return unless new_identifier.basic_literal?
 
           new_identifier = new_identifier.value

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -7,11 +7,11 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     expect(cop.messages).to eq([described_class::MSG])
+      #   # bad
+      #   expect(cop.messages).to eq([described_class::MSG])
       #
-      #     # good
-      #     expect(cop.messages).to eq(['Do not write bad code like that.'])
+      #   # good
+      #   expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
       class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'

data/lib/rubocop/cop/internal_affairs.rb

@@ -7,6 +7,7 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
+require_relative 'internal_affairs/itblock_handler'
 require_relative 'internal_affairs/lambda_or_proc'
 require_relative 'internal_affairs/location_exists'
 require_relative 'internal_affairs/location_expression'

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method call are aligned.
+      # Checks that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good
@@ -52,7 +52,7 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
+          return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
                     autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the elements of a multi-line array literal are
+      # Checks that the elements of a multi-line array literal are
       # aligned.
       #
       # @example EnforcedStyle: with_first_element (default)

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

@@ -128,7 +128,9 @@ module RuboCop
           return if case_match_node.single_line?
           return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
 
-          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
+          case_match_node.in_pattern_branches.each do |in_pattern_node|
+            check_when(in_pattern_node, 'in')
+          end
         end
 
         private

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

@@ -223,7 +223,7 @@ module RuboCop
         # @param node to be analysed
         # @return String when the node type is a `:block` then
         #   {classify} recursively with the first children
-        # @return String when the node type is a `:send` then {find_category}
+        # @return String when the node type is a `:send` then {find_send_node_category}
         #   by method name
         # @return String otherwise trying to {humanize_node} of the current node
         def classify(node)
@@ -233,9 +233,10 @@ module RuboCop
           when :block
             classify(node.send_node)
           when :send
-            find_category(node)
+            find_send_node_category(node)
           else
-            humanize_node(node)
+            name = humanize_node(node)
+            find_category(name) || name
           end.to_s
         end
 
@@ -244,9 +245,9 @@ module RuboCop
         # also its visibility.
         # @param node to be analysed.
         # @return [String] with the key category or the `method_name` as string
-        def find_category(node)
+        def find_send_node_category(node)
           name = node.method_name.to_s
-          category, = categories.find { |_, names| names.include?(name) }
+          category = find_category(name)
           key = category || name
           visibility_key =
             if node.def_modifier?
@@ -257,6 +258,12 @@ module RuboCop
           expected_order.include?(visibility_key) ? visibility_key : key
         end
 
+        def find_category(name)
+          name = name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          category
+        end
+
         def walk_over_nested_class_definition(class_node)
           class_elements(class_node).each do |node|
             classification = classify(node)
@@ -357,7 +364,7 @@ module RuboCop
         end
 
         def find_heredoc(node)
-          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+          node.each_node(:any_str).find(&:heredoc?)
         end
 
         def buffer

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def last_heredoc_line(node)
-          if node.send_type?
+          if node.call_type?
             node.arguments.select { |arg| heredoc?(arg) }.map { |arg| arg.loc.heredoc_end.line }.max
           elsif heredoc?(node)
             node.loc.heredoc_end.line
@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc?
+          node.any_str_type? && node.heredoc?
         end
 
         def end_range(node)

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

@@ -60,6 +60,11 @@ module RuboCop
         END_OF_HEREDOC_LINE = 1
         SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
+        # @!method guard_clause_branch?(node)
+        def_node_matcher :guard_clause_branch?, <<~PATTERN
+          {(send nil? {:raise :fail} ...) return break next}
+        PATTERN
+
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
@@ -97,14 +102,16 @@ module RuboCop
         end
 
         def correct_style?(node)
-          !contains_guard_clause?(node) ||
+          !node.if_branch&.guard_clause? ||
             next_line_rescue_or_ensure?(node) ||
             next_sibling_parent_empty_or_else?(node) ||
             next_sibling_empty_or_guard_clause?(node)
         end
 
         def contains_guard_clause?(node)
-          node.if_branch&.guard_clause?
+          return false unless (branch = node.if_branch)
+
+          branch.guard_clause? || guard_clause_branch?(branch)
         end
 
         def next_line_empty_or_allowed_directive_comment?(line)
@@ -145,8 +152,10 @@ module RuboCop
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def last_heredoc_argument(node)
           n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -158,6 +167,7 @@ module RuboCop
 
           last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def last_heredoc_argument_node(node)
           return node unless node.respond_to?(:if_branch)

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

@@ -76,28 +76,40 @@ module RuboCop
       #   # good
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # good - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       # @example AllowAdjacentOneLineDefs: false
       #
       #   # bad
       #   class ErrorA < BaseError; end
       #   class ErrorB < BaseError; end
-      #   class ErrorC < BaseError; end
       #
       #   # good
       #   class ErrorA < BaseError; end
       #
       #   class ErrorB < BaseError; end
       #
-      #   class ErrorC < BaseError; end
+      #   # bad - DefLikeMacros: [memoize]
+      #   memoize :attribute_a
+      #   memoize :attribute_b
+      #
+      #   # good
+      #   memoize :attribute_a
+      #
+      #   memoize :attribute_b
       #
       class EmptyLineBetweenDefs < Base
         include RangeHelp
@@ -158,6 +170,8 @@ module RuboCop
         def def_location(correction_node)
           if correction_node.any_block_type?
             correction_node.source_range.join(correction_node.children.first.source_range)
+          elsif correction_node.send_type?
+            correction_node.source_range
           else
             correction_node.loc.keyword.join(correction_node.loc.name)
           end
@@ -171,12 +185,18 @@ module RuboCop
         end
 
         def empty_line_between_macros
-          cop_config.fetch('DefLikeMacros', []).map(&:to_sym)
+          @empty_line_between_macros ||= cop_config.fetch('DefLikeMacros', []).map(&:to_sym).freeze
         end
 
         def macro_candidate?(node)
-          node.any_block_type? && node.children.first.macro? &&
-            empty_line_between_macros.include?(node.children.first.method_name)
+          macro_candidate = if node.any_block_type?
+                              node.send_node
+                            elsif node.send_type?
+                              node
+                            end
+          return false unless macro_candidate
+
+          macro_candidate.macro? && empty_line_between_macros.include?(macro_candidate.method_name)
         end
 
         def method_candidate?(node)
@@ -240,7 +260,9 @@ module RuboCop
         end
 
         def def_start(node)
-          if node.any_block_type? && node.children.first.send_type?
+          node = node.send_node if node.any_block_type?
+
+          if node.send_type?
             node.source_range.line
           else
             node.loc.keyword.line
@@ -252,11 +274,7 @@ module RuboCop
         end
 
         def end_loc(node)
-          if node.any_def_type? && node.endless?
-            node.source_range.end
-          else
-            node.loc.end
-          end
+          node.source_range.end
         end
 
         def autocorrect_remove_lines(corrector, newline_pos, count)

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

@@ -39,7 +39,7 @@ module RuboCop
 
         def on_send(node)
           return if node.receiver || node.arguments.empty?
-          return if node.parent&.type?(:send, :any_block)
+          return if node.parent&.type?(:send, :any_block, :array)
 
           return if next_line_empty_or_enable_directive_comment?(node.last_line)
 

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

@@ -66,6 +66,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Add an empty line after attribute accessor.'
+        RESTRICT_ON_SEND = %i[attr_reader attr_writer attr_accessor attr].freeze
 
         def on_send(node)
           return unless node.attribute_accessor?

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

@@ -7,15 +7,25 @@ module RuboCop
       # the configuration.
       #
       # @example EnforcedStyle: no_empty_lines (default)
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #
+      #     # ...
+      #
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #     # ...
       #   end
       #
       # @example EnforcedStyle: empty_lines
-      #   # good
+      #   # bad
+      #   foo do |bar|
+      #     # ...
+      #   end
       #
+      #   # good
       #   foo do |bar|
       #
       #     # ...