rubocop 1.53.0 → 1.90.0

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

@@ -3,40 +3,45 @@
 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
       #
       #   # bad
       #   Gem::Specification.new do |spec|
       #     if RUBY_VERSION >= '3.0'
-      #       spec.add_runtime_dependency 'gem_a'
+      #       spec.add_dependency 'gem_a'
       #     else
-      #       spec.add_runtime_dependency 'gem_b'
+      #       spec.add_dependency 'gem_b'
       #     end
       #   end
       #
       #   # good
       #   Gem::Specification.new do |spec|
-      #     spec.add_runtime_dependency 'gem_a'
+      #     spec.add_dependency 'gem_a'
       #   end
       #
       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/require_file_injector.rb

@@ -67,7 +67,7 @@ module RuboCop
 
         def require_path
           path = source_path.relative_path_from(root_file_path.dirname)
-          path.to_s.sub('.rb', '')
+          path.to_s.delete_suffix('.rb')
         end
       end
     end

data/lib/rubocop/cop/generator.rb

@@ -71,11 +71,17 @@ module RuboCop
                   (send nil? :bad_method ...)
                 PATTERN
 
+                # Called on every `send` node (method call) while walking the AST.
+                # TODO: remove this method if inspecting `send` nodes is unneeded for your cop.
+                # By default, this is aliased to `on_csend` as well to handle method calls
+                # with safe navigation, remove the alias if this is unnecessary.
+                # If kept, ensure your tests cover safe navigation as well!
                 def on_send(node)
                   return unless bad_method?(node)
 
                   add_offense(node)
                 end
+                alias on_csend on_send
               end
             end
           end
@@ -130,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 =

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

@@ -112,10 +112,6 @@ module RuboCop
           body = comment_body(comment_line)
           node.source.index(body)
         end
-
-        def relevant_file?(file)
-          file.match?(%r{/cop/.*\.rb\z})
-        end
       end
     end
   end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `config.cop_enabled?('Department/CopName')` instead of
+      # traversing the config hash.
+      #
+      # @example
+      #   # `for_cop(...)['Enabled']
+      #
+      #   # bad
+      #   config.for_cop('Department/CopName')['Enabled']
+      #
+      #   # good
+      #   config.cop_enabled?('Department/CopName')
+      #
+      # @example
+      #   # when keeping a cop's config in a local and then checking the `Enabled` key
+      #
+      #   # bad
+      #   cop_config = config.for_cop('Department/CopName')
+      #   cop_config['Enabled'] && cop_config['Foo']
+      #
+      #   # good
+      #   config.for_enabled_cop('Department/CopName')['Foo']
+      #
+      class CopEnabled < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG_HASH = 'Consider replacing uses of `%<hash_name>s` with `config.for_enabled_cop`.'
+
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        # @!method for_cop_enabled?(node)
+        def_node_matcher :for_cop_enabled?, <<~PATTERN
+          (send
+            (send
+              ${(send nil? :config) (ivar :@config)} :for_cop
+              $(str _)) :[]
+            (str "Enabled"))
+        PATTERN
+
+        # @!method config_enabled_lookup?(node)
+        def_node_matcher :config_enabled_lookup?, <<~PATTERN
+          (send
+            {(lvar $_) (ivar $_) (send nil? $_)} :[]
+            (str "Enabled"))
+        PATTERN
+
+        def on_send(node)
+          if (config_var, cop_name = for_cop_enabled?(node))
+            handle_for_cop(node, config_var, cop_name)
+          elsif (config_var = config_enabled_lookup?(node))
+            return unless config_var.end_with?('_config')
+
+            handle_hash(node, config_var)
+          end
+        end
+
+        private
+
+        def handle_for_cop(node, config_var, cop_name)
+          source = node.source
+          quote = cop_name.loc.begin.source
+          cop_name = cop_name.value
+
+          replacement = "#{config_var.source}.cop_enabled?(#{quote}#{cop_name}#{quote})"
+          message = format(MSG, source: source, replacement: replacement)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def handle_hash(node, config_var)
+          message = format(MSG_HASH, hash_name: config_var)
+
+          add_offense(node, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -38,7 +38,8 @@ module RuboCop
         CORRECTION_EXPECTATION_METHODS = %i[expect_correction expect_no_corrections].freeze
 
         def on_send(node)
-          return unless (next_sibling = node.right_sibling) && next_sibling.send_type?
+          return unless (next_sibling = node.right_sibling)
+          return unless next_sibling.respond_to?(:send_type?) && next_sibling.send_type?
 
           method_name = next_sibling.method_name
           return unless CORRECTION_EXPECTATION_METHODS.include?(method_name)

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

@@ -26,9 +26,7 @@ module RuboCop
       #     expect_no_offenses('...')
       #   end
       class ExampleDescription < Base
-        class << self
-          attr_accessor :descriptions
-        end
+        extend AutoCorrector
 
         MSG = 'Description does not match use of `%<method_name>s`.'
 
@@ -39,26 +37,39 @@ module RuboCop
           expect_no_corrections
         ].to_set.freeze
 
-        EXPECT_NO_OFFENSES_INCORRECT_DESCRIPTIONS = [
-          /^(adds|registers|reports|finds) (an? )?offense/,
-          /^(flags|handles|works)\b/
-        ].freeze
+        EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING = {
+          /\A(adds|registers|reports|finds) (an? )?offense/ => 'does not register an offense',
+          /\A(flags|handles|works)\b/ => 'does not register'
+        }.freeze
+
+        EXPECT_OFFENSE_DESCRIPTION_MAPPING = {
+          /\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|allows|register)\b/ => 'registers'
+        }.freeze
 
-        EXPECT_OFFENSE_INCORRECT_DESCRIPTIONS = [
-          /^(does not|doesn't) (register|find|flag|report)/,
-          /^(does not|doesn't) add (a|an|any )?offense/
-        ].freeze
+        EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
+          /\A(auto[- ]?)?corrects?/ => 'does not correct',
+          /\band (auto[- ]?)?corrects/ => 'but does not correct'
+        }.freeze
 
-        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [/^(auto[- ]?)?correct/].freeze
+        EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\bbut (does not|doesn't) (auto[- ]?)?correct/ => 'and autocorrects',
+          /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
+        }.freeze
 
-        EXPECT_CORRECTION_INCORRECT_DESCRIPTIONS = [
-          /\b(does not|doesn't) (auto[- ]?)?correct/
-        ].freeze
+        EXAMPLE_DESCRIPTION_MAPPING = {
+          expect_no_offenses: EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING,
+          expect_offense: EXPECT_OFFENSE_DESCRIPTION_MAPPING,
+          expect_no_corrections: EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING,
+          expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
+        }.freeze
 
-        # @!method offense_example?(node)
-        def_node_matcher :offense_example?, <<~PATTERN
+        # @!method offense_example(node)
+        def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $_description)
+            (send _ {:it :specify :xit :fit} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -66,25 +77,40 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (description = offense_example?(parent))
+          return unless parent && (current_description = offense_example(parent)&.first)
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)
 
-          regexp_group = self.class.const_get("#{method_name}_incorrect_descriptions".upcase)
-          check_description(description, regexp_group, message)
+          description_map = EXAMPLE_DESCRIPTION_MAPPING[method_name]
+          check_description(current_description, description_map, message)
         end
 
         private
 
-        def check_description(description, regexps, message)
-          return unless regexps.any? { |regexp| regexp.match?(string_contents(description)) }
+        def check_description(current_description, description_map, message)
+          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, "#{quote}#{new_description}#{quote}")
+          end
+        end
+
+        def correct_description(current_description, description_map)
+          description_map.each do |incorrect_description_pattern, preferred_description|
+            if incorrect_description_pattern.match?(current_description)
+              return current_description.gsub(incorrect_description_pattern, preferred_description)
+            end
+          end
 
-          add_offense(description, message: message)
+          nil
         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