rubocop 1.71.1 → 1.91.0

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

@@ -3,11 +3,11 @@
 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` is dangerous because the 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.
+      # It's possible to have a dependency based on the Ruby version used
+      # to execute `rake release` and not the user's Ruby version.
       #
       # @example
       #
@@ -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/gemspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Gemspec` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Gemspec
+      extend LazyLoader
+
+      register_cop :AddRuntimeDependency, "#{__dir__}/gemspec/add_runtime_dependency"
+      register_cop :AttributeAssignment, "#{__dir__}/gemspec/attribute_assignment"
+      register_cop :DependencyVersion, "#{__dir__}/gemspec/dependency_version"
+      register_cop :DeprecatedAttributeAssignment, "#{__dir__}/gemspec/deprecated_attribute_assignment"
+      register_cop :DevelopmentDependencies, "#{__dir__}/gemspec/development_dependencies"
+      register_cop :DuplicatedAssignment, "#{__dir__}/gemspec/duplicated_assignment"
+      register_cop :OrderedDependencies, "#{__dir__}/gemspec/ordered_dependencies"
+      register_cop :RequireMFA, "#{__dir__}/gemspec/require_mfa"
+      register_cop :RequiredRubyVersion, "#{__dir__}/gemspec/required_ruby_version"
+      register_cop :RubyVersionGlobalsUsage, "#{__dir__}/gemspec/ruby_version_globals_usage"
+    end
+  end
+end

data/lib/rubocop/cop/generator/registration_injector.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class Generator
+      # A class that injects a `register_cop` directive into the cop's department module
+      # so that the new cop is registered for lazy loading.
+      # The directive is injected in alphabetical order among the existing directives without
+      # reordering them, since the registration order defines the cop execution order.
+      # When the department module file does not exist yet, it is created, and a require for
+      # it is injected into the root RuboCop file.
+      #
+      # Anything unexpected in the department module, such as a commented-out or otherwise
+      # unparsable `register_cop` line, raises an error instead of silently producing
+      # a broken registration.
+      class RegistrationInjector
+        EXTEND_PATTERN = /\A(?<indent>\s*)extend LazyLoader\n\z/.freeze
+        ENTRY_PATTERN = %r{
+          \A(?<indent>\s*)register_cop\s
+          :(?<constant>[A-Za-z0-9]+),\s
+          "\#\{__dir__\}/(?<path>[a-z0-9_/]+)"\n\z
+        }x.freeze
+        DEPARTMENT_REQUIRE_PATTERN = %r{\Arequire_relative 'rubocop/cop/[a-z0-9_/]+'\n\z}.freeze
+
+        def initialize(source_path:, badge:, root_file_path: 'lib/rubocop.rb', output: $stdout)
+          @source_path = Pathname(source_path)
+          @badge = badge
+          @root_file_path = root_file_path
+          @department_file_path = Pathname("#{@source_path.dirname}.rb")
+          @output = output
+        end
+
+        def inject
+          if File.exist?(department_file_path)
+            inject_directive
+          else
+            create_department_file
+            inject_department_require
+          end
+        end
+
+        private
+
+        attr_reader :source_path, :badge, :root_file_path, :department_file_path, :output
+
+        def inject_directive
+          lines = File.readlines(department_file_path)
+          entries = parse_entries(lines)
+          return if entries.any? { |entry| entry[:path] == cop_path }
+
+          line, indent = insertion_point(lines, entries)
+          lines.insert(line, "#{indent}#{directive}\n")
+
+          write_department_file(lines)
+        end
+
+        def create_department_file
+          File.write(department_file_path, department_module_source)
+
+          output.puts "[create] #{department_file_path}"
+        end
+
+        def inject_department_require
+          require_path = department_file_path.sub_ext('').to_s.delete_prefix('lib/')
+          require_directive = "require_relative '#{require_path}'\n"
+
+          lines = File.readlines(root_file_path)
+          return if lines.include?(require_directive)
+
+          lines.insert(department_require_index(lines, require_directive), require_directive)
+          File.write(root_file_path, lines.join)
+
+          output.puts "[modify] #{root_file_path} - `#{require_directive.strip}` was injected."
+        end
+
+        def write_department_file(lines)
+          File.write(department_file_path, lines.join)
+
+          output.puts "[modify] #{department_file_path} - `#{directive}` was injected."
+        end
+
+        # @return [Array<Hash>] the `register_cop` entries with their line numbers
+        def parse_entries(lines)
+          lines.filter_map.with_index do |line, index|
+            match = ENTRY_PATTERN.match(line)
+
+            if match
+              { line: index, indent: match[:indent], constant: match[:constant],
+                path: match[:path] }
+            elsif line.include?('register_cop')
+              raise Error, "unexpected `register_cop` line in #{department_file_path}:" \
+                           "#{index + 1}; fix it or register the cop manually: #{line}"
+            end
+          end
+        end
+
+        # The directive path is relative to the department module file's directory,
+        # which `__dir__` resolves to at load time.
+        def cop_path
+          source_path.relative_path_from(department_file_path.dirname).to_s.delete_suffix('.rb')
+        end
+
+        def insertion_point(lines, entries)
+          if entries.empty?
+            first_directive_position(lines)
+          else
+            successor = entries.find { |entry| entry[:path] > cop_path }
+            entry = successor || entries.last
+
+            [entry[:line] + (successor ? 0 : 1), entry[:indent]]
+          end
+        end
+
+        def directive
+          "register_cop :#{badge.cop_name}, \"\#{__dir__}/#{cop_path}\""
+        end
+
+        # The department requires form the contiguous block right before
+        # the `rubocop/cop/team` require in the root RuboCop file.
+        def department_require_index(lines, require_directive)
+          anchor = lines.index("require_relative 'rubocop/cop/team'\n")
+          unless anchor
+            raise Error, "could not find the department require block in #{root_file_path}"
+          end
+
+          block_end = anchor - 1
+          block_end -= 1 while lines[block_end] == "\n"
+          block_start = block_end
+          block_start -= 1 while lines[block_start - 1]&.match?(DEPARTMENT_REQUIRE_PATTERN)
+
+          (block_start..block_end).find do |index|
+            lines[index] > require_directive
+          end || (block_end + 1)
+        end
+
+        def first_directive_position(lines)
+          extend_lines = lines.filter_map.with_index do |line, index|
+            [index, EXTEND_PATTERN.match(line)[:indent]] if EXTEND_PATTERN.match?(line)
+          end
+
+          unless extend_lines.size == 1
+            raise Error, "expected `extend LazyLoader` in #{department_file_path}; " \
+                         'add it or register the cop manually'
+          end
+
+          index, indent = extend_lines.first
+          blank_after_extend = lines[index + 1] == "\n"
+
+          [index + (blank_after_extend ? 2 : 1), indent]
+        end
+
+        def department_module_source
+          modules = %w[RuboCop Cop] + badge.department.to_s.split('/')
+          body_indent = '  ' * modules.size
+
+          lines = ['# frozen_string_literal: true', '']
+          lines.concat(module_opening_lines(modules))
+          lines << "#{body_indent}extend LazyLoader"
+          lines << ''
+          lines << "#{body_indent}#{directive}"
+          lines.concat(module_closing_lines(modules))
+
+          "#{lines.join("\n")}\n"
+        end
+
+        def module_opening_lines(modules)
+          modules.flat_map.with_index do |mod, nesting|
+            indent = '  ' * nesting
+            lines = []
+
+            if mod == modules.last
+              lines << "#{indent}# Cops for the `#{badge.department}` department. " \
+                       "The department's cops are"
+              lines << "#{indent}# registered for lazy loading and their files are " \
+                       'loaded on demand.'
+            end
+
+            lines << "#{indent}module #{mod}"
+          end
+        end
+
+        def module_closing_lines(modules)
+          (modules.size - 1).downto(0).map { |nesting| "#{'  ' * nesting}end" }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/generator.rb

@@ -136,6 +136,10 @@ module RuboCop
         RequireFileInjector.new(source_path: source_path, root_file_path: root_file_path).inject
       end
 
+      def inject_registration
+        RegistrationInjector.new(source_path: source_path, badge: badge).inject
+      end
+
       def inject_config(config_file_path: 'config/default.yml',
                         version_added: '<<next>>')
         injector =
@@ -143,7 +147,7 @@ module RuboCop
                                     badge: badge,
                                     version_added: version_added)
 
-        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity
+        injector.inject do # rubocop:disable Lint/UnexpectedBlockArity -- this `inject` is the injector API, not `Enumerable#inject`
           output.puts(format(CONFIGURATION_ADDED_MESSAGE,
                              configuration_file_path: config_file_path))
         end

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

@@ -46,14 +46,16 @@ module RuboCop
           /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
           /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
           /\Aregisters no offense/ => 'registers an offense',
-          /\A(accepts|register)\b/ => 'registers'
+          /\A(accepts|allows|register)\b/ => 'registers'
         }.freeze
 
         EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
-          /\A(auto[- ]?)?correct/ => 'does not correct'
+          /\A(auto[- ]?)?corrects?/ => 'does not correct',
+          /\band (auto[- ]?)?corrects/ => 'but does not correct'
         }.freeze
 
         EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\bbut (does not|doesn't) (auto[- ]?)?correct/ => 'and autocorrects',
           /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
         }.freeze
 
@@ -67,7 +69,7 @@ module RuboCop
         # @!method offense_example(node)
         def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $...)
+            (send _ {:it :specify :xit :fit} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -90,8 +92,10 @@ module RuboCop
           description_text = string_contents(current_description)
           return unless (new_description = correct_description(description_text, description_map))
 
+          quote = current_description.dstr_type? ? '"' : "'"
+
           add_offense(current_description, message: message) do |corrector|
-            corrector.replace(current_description, "'#{new_description}'")
+            corrector.replace(current_description, "#{quote}#{new_description}#{quote}")
           end
         end
 
@@ -106,7 +110,7 @@ module RuboCop
         end
 
         def string_contents(node)
-          node.str_type? ? node.value : node.source
+          node.type?(:str, :dstr) ? node.value : node.source
         end
       end
     end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # When a node location may not exist, `Node#loc?` or `Node#loc_is?`
+      # can be used instead of calling `Node#respond_to?` before using
+      # the value.
+      #
+      # @example
+      #   # bad
+      #   node.loc.respond_to?(:begin)
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.is?('(')
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.source == '('
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      class LocationExists < Base
+        extend AutoCorrector
+
+        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
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            {
+              (call
+                (call
+                  (call _receiver :loc) _location) :is?
+                $(str _))
+              (call
+                (call
+                  (call
+                    (call _receiver :loc) _location) :source) :==
+                    $(str _))
+            })
+        PATTERN
+
+        # @!method replaceable_with_loc(node)
+        def_node_matcher :replaceable_with_loc, <<~PATTERN
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            (call
+              (call _receiver :loc) _location))
+        PATTERN
+
+        def on_and(node)
+          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)
+          replaceable_with_loc(node) do |receiver, location|
+            if node.parent&.assignment?
+              register_offense(node, replace_assignment(receiver, location))
+            else
+              register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+            end
+          end
+        end
+
+        def replace_with_loc_is(node)
+          replaceable_with_loc_is(node) do |receiver, location, value|
+            replacement = replacement(receiver, "loc_is?(#{location.source}, #{value.source})")
+            register_offense(node, replacement)
+          end
+        end
+
+        def register_offense(node, replacement)
+          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)
+          "#{replace_receiver(receiver)}#{rest}"
+        end
+
+        def replace_assignment(receiver, location)
+          prefix = replace_receiver(receiver)
+
+          "#{prefix}loc#{dot(receiver)}#{location.value} if #{prefix}loc?(#{location.source})"
+        end
+
+        def replace_receiver(receiver)
+          return '' unless receiver
+
+          "#{receiver.source}#{dot(receiver)}"
+        end
+
+        def dot(node)
+          node.parent.loc.dot.source
+        end
+      end
+    end
+  end
+end

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

@@ -25,6 +25,7 @@ module RuboCop
         def_node_matcher :line_send, <<~PATTERN
           {
             (send (send _ {:loc :source_range}) {:line :first_line})
+            (send (send (send _ :loc) {:begin :end}) :line)
             (send _ :first_line)
           }
         PATTERN

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
@@ -110,8 +110,8 @@ module RuboCop
         def directive_offense_type(directive, actual_name)
           return :missing_directive unless directive
 
-          return :wrong_scope if wrong_scope(directive, actual_name)
-          return :no_scope if no_scope(directive, actual_name)
+          return :wrong_scope if wrong_scope?(directive, actual_name)
+          return :no_scope if no_scope?(directive, actual_name)
 
           # The method directive being prefixed by 'self.' is always an offense.
           # The matched method_name does not contain the receiver but the
@@ -121,11 +121,11 @@ module RuboCop
           end
         end
 
-        def wrong_scope(directive, actual_name)
+        def wrong_scope?(directive, actual_name)
           !actual_name.start_with?('self.') && directive[:has_scope_directive]
         end
 
-        def no_scope(directive, actual_name)
+        def no_scope?(directive, actual_name)
           actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 
@@ -146,7 +146,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def formatted_message(offense_type, directive, actual_name, method_name)
           case offense_type
           when :wrong_name
@@ -166,7 +166,6 @@ module RuboCop
             format(MSG, method: method_name)
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def remove_receiver(current)
           current.delete_prefix('self.')

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # rubocop:disable InternalAffairs/RedundantSourceRange - node here is a `NodePattern::Node`
+      # rubocop:disable-next InternalAffairs/RedundantSourceRange -- node here is a `NodePattern::Node`
       class NodePatternGroups
         # Walks an AST that has been processed by `InternalAffairs::NodePatternGroups::Processor`
         # in order to find `node_type` and `node_sequence` nodes that can be replaced with a node
@@ -125,7 +125,6 @@ module RuboCop
           end
         end
       end
-      # rubocop:enable InternalAffairs/RedundantSourceRange
     end
   end
 end

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

@@ -27,7 +27,11 @@ module RuboCop
         MSG = 'Replace `%<names>s` in node pattern union with `%<replacement>s`.'
         RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].freeze
         NODE_GROUPS = {
-          any_block: %i[block numblock],
+          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],
@@ -208,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)