rubocop 1.52.1 → 1.79.2

data/lib/rubocop/plugin/loader.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../feature_loader'
+require_relative 'load_error'
+
+module RuboCop
+  module Plugin
+    # A class for loading and resolving plugins.
+    # @api private
+    class Loader
+      # rubocop:disable Layout/LineLength
+      DEFAULT_PLUGIN_CONFIG = {
+        'enabled' => true,
+        'require_path' => nil, # If not set, will be set to the plugin name
+        'plugin_class_name' => nil # If not set, looks for gemspec `spec.metadata["default_lint_roller_plugin"]`
+      }.freeze
+
+      # rubocop:enable Layout/LineLength
+      class << self
+        def load(plugins)
+          normalized_plugin_configs = normalize(plugins)
+          normalized_plugin_configs.filter_map do |plugin_name, plugin_config|
+            next unless plugin_config['enabled']
+
+            plugin_class = constantize_plugin_from(plugin_name, plugin_config)
+
+            plugin_class.new(plugin_config)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def normalize(plugin_configs)
+          plugin_configs.to_h do |plugin_config|
+            if plugin_config == Plugin::OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+              warn Rainbow(<<~MESSAGE).yellow
+                Specify `rubocop-internal_affairs` instead of `rubocop/cop/internal_affairs` in your configuration.
+              MESSAGE
+              plugin_config = Plugin::INTERNAL_AFFAIRS_PLUGIN_NAME
+            end
+
+            if plugin_config.is_a?(Hash)
+              plugin_name = plugin_config.keys.first
+
+              [
+                plugin_name, DEFAULT_PLUGIN_CONFIG.merge(
+                  { 'require_path' => plugin_name }, plugin_config.values.first
+                )
+              ]
+            # NOTE: Compatibility is maintained when `require: rubocop/cop/internal_affairs` remains
+            # specified in `.rubocop.yml`.
+            elsif (builtin_plugin_config = Plugin::BUILTIN_INTERNAL_PLUGINS[plugin_config])
+              [plugin_config, builtin_plugin_config]
+            else
+              [plugin_config, DEFAULT_PLUGIN_CONFIG.merge('require_path' => plugin_config)]
+            end
+          end
+        end
+
+        def constantize_plugin_from(plugin_name, plugin_config)
+          if plugin_name.is_a?(String) || plugin_name.is_a?(Symbol)
+            constantize(plugin_name, plugin_config)
+          else
+            plugin_name
+          end
+        end
+
+        # rubocop:enable Metrics/MethodLength
+        def constantize(plugin_name, plugin_config)
+          require_plugin(plugin_config['require_path'])
+
+          if (constant_name = plugin_config['plugin_class_name'])
+            begin
+              Kernel.const_get(constant_name)
+            rescue StandardError
+              raise <<~MESSAGE
+                Failed while configuring plugin `#{plugin_name}': no constant with name `#{constant_name}' was found.
+              MESSAGE
+            end
+          else
+            constantize_plugin_from_gemspec_metadata(plugin_name)
+          end
+        end
+
+        def require_plugin(require_path)
+          FeatureLoader.load(config_directory_path: Dir.pwd, feature: require_path)
+        end
+
+        def constantize_plugin_from_gemspec_metadata(plugin_name)
+          plugin_class_name = Gem.loaded_specs[plugin_name].metadata['default_lint_roller_plugin']
+
+          Kernel.const_get(plugin_class_name)
+        rescue LoadError, StandardError
+          raise Plugin::LoadError, plugin_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/not_supported_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Plugin
+    # An exception raised when a plugin is not supported by the RuboCop engine.
+    # @api private
+    class NotSupportedError < Error
+      def initialize(unsupported_plugins)
+        super
+
+        @unsupported_plugins = unsupported_plugins
+      end
+
+      def message
+        if @unsupported_plugins.one?
+          about = @unsupported_plugins.first.about
+
+          "#{about.name} #{about.version} is not a plugin supported by RuboCop engine."
+        else
+          unsupported_plugin_names = @unsupported_plugins.map do |plugin|
+            "#{plugin.about.name} #{plugin.about.version}"
+          end.join(', ')
+
+          "#{unsupported_plugin_names} are not plugins supported by RuboCop engine."
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'plugin/configuration_integrator'
+require_relative 'plugin/loader'
+
+module RuboCop
+  # Provides a plugin for RuboCop extensions that conform to lint_roller.
+  # https://github.com/standardrb/lint_roller
+  # @api private
+  module Plugin
+    BUILTIN_INTERNAL_PLUGINS = {
+      'rubocop-internal_affairs' => {
+        'enabled' => true,
+        'require_path' => 'rubocop/cop/internal_affairs/plugin',
+        'plugin_class_name' => 'RuboCop::InternalAffairs::Plugin'
+      }
+    }.freeze
+    INTERNAL_AFFAIRS_PLUGIN_NAME = Plugin::BUILTIN_INTERNAL_PLUGINS.keys.first
+    OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME = 'rubocop/cop/internal_affairs'
+
+    class << self
+      def plugin_capable?(feature_name)
+        return true if BUILTIN_INTERNAL_PLUGINS.key?(feature_name)
+        return true if feature_name == OBSOLETE_INTERNAL_AFFAIRS_PLUGIN_NAME
+
+        begin
+          # When not using Bundler. Makes the spec available but does not require it.
+          gem feature_name
+        rescue Gem::LoadError
+          # The user requested a gem that they do not have installed
+        end
+        return false unless (spec = Gem.loaded_specs[feature_name])
+
+        !!spec.metadata['default_lint_roller_plugin']
+      end
+
+      def integrate_plugins(rubocop_config, plugins)
+        plugins = Plugin::Loader.load(plugins)
+
+        ConfigurationIntegrator.integrate_plugins_into_rubocop_config(rubocop_config, plugins)
+
+        plugins
+      end
+    end
+  end
+end

data/lib/rubocop/rake_task.rb

@@ -12,7 +12,8 @@ module RuboCop
   # Use global Rake namespace here to avoid namespace issues with custom
   # rubocop-rake tasks
   class RakeTask < ::Rake::TaskLib
-    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
+    attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :plugins, :requires,
+                  :options
 
     def initialize(name = :rubocop, *args, &task_block)
       super()
@@ -44,7 +45,7 @@ module RuboCop
     def run_cli(verbose, options)
       # We lazy-load RuboCop so that the task doesn't dramatically impact the
       # load time of your Rakefile.
-      require 'rubocop'
+      require_relative '../rubocop'
 
       cli = CLI.new
       puts 'Running RuboCop...' if verbose
@@ -54,6 +55,7 @@ module RuboCop
 
     def full_options
       formatters.map { |f| ['--format', f] }.flatten
+                .concat(plugins.map { |plugin| ['--plugin', plugin] }.flatten)
                 .concat(requires.map { |r| ['--require', r] }.flatten)
                 .concat(options.flatten)
                 .concat(patterns)
@@ -64,6 +66,7 @@ module RuboCop
       @verbose = true
       @fail_on_error = true
       @patterns = []
+      @plugins = []
       @requires = []
       @options = []
       @formatters = []

data/lib/rubocop/remote_config.rb

@@ -12,7 +12,11 @@ module RuboCop
     CACHE_LIFETIME = 24 * 60 * 60
 
     def initialize(url, base_dir)
-      @uri = URI.parse(url)
+      begin
+        @uri = URI.parse(url)
+      rescue URI::InvalidURIError
+        raise ConfigNotFoundError, "Failed to resolve configuration: '#{url}' is not a valid URI"
+      end
       @base_dir = base_dir
     end
 

data/lib/rubocop/result_cache.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'digest/sha1'
-require 'etc'
 require 'find'
 require 'zlib'
 require_relative 'cache_config'
@@ -26,16 +25,16 @@ module RuboCop
     # cleaning should be done relatively seldom, since there is a slight risk
     # that some other RuboCop process was just about to read the file, when
     # there's parallel execution and the cache is shared.
-    def self.cleanup(config_store, verbose, cache_root = nil)
+    def self.cleanup(config_store, verbose, cache_root_override = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
 
-      cache_root ||= cache_root(config_store)
-      return unless File.exist?(cache_root)
+      rubocop_cache_dir = cache_root(config_store, cache_root_override)
+      return unless File.exist?(rubocop_cache_dir)
 
-      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      files, dirs = Find.find(rubocop_cache_dir).partition { |path| File.file?(path) }
       return unless requires_file_removal?(files.length, config_store)
 
-      remove_oldest_files(files, dirs, cache_root, verbose)
+      remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
     end
 
     class << self
@@ -50,11 +49,11 @@ module RuboCop
         file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
-      def remove_oldest_files(files, dirs, cache_root, verbose)
+      def remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
         remove_count = (files.length / 2) + 1
-        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
+        puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)
       rescue Errno::ENOENT
@@ -73,9 +72,9 @@ module RuboCop
       end
     end
 
-    def self.cache_root(config_store)
+    def self.cache_root(config_store, cache_root_override = nil)
       CacheConfig.root_dir do
-        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+        cache_root_override || config_store.for_pwd.for_all_cops['CacheRootDirectory']
       end
     end
 
@@ -85,12 +84,12 @@ module RuboCop
 
     attr_reader :path
 
-    def initialize(file, team, options, config_store, cache_root = nil)
-      cache_root ||= File.join(options[:cache_root], 'rubocop_cache') if options[:cache_root]
-      cache_root ||= ResultCache.cache_root(config_store)
+    def initialize(file, team, options, config_store, cache_root_override = nil)
+      cache_root_override ||= options[:cache_root] if options[:cache_root]
+      rubocop_cache_dir = ResultCache.cache_root(config_store, cache_root_override)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root,
+      @path = File.join(rubocop_cache_dir,
                         rubocop_checksum,
                         context_checksum(team, options),
                         file_checksum(file, config_store))
@@ -199,16 +198,22 @@ module RuboCop
     end
 
     def rubocop_extra_features
-      lib_root = File.join(File.dirname(__FILE__), '..')
-      exe_root = File.join(lib_root, '..', 'exe')
+      @rubocop_extra_features ||= begin
+        lib_root = File.join(File.dirname(__FILE__), '..')
+        exe_root = File.join(lib_root, '..', 'exe')
 
-      # These are all the files we have `require`d plus everything in the
-      # exe directory. A change to any of them could affect the cop output
-      # so we include them in the cache hash.
-      source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
-      source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+        # Make sure to use an absolute path to prevent errors on Windows
+        # when traversing the relative paths with symlinks.
+        exe_root = File.absolute_path(exe_root)
 
-      source_files
+        # These are all the files we have `require`d plus everything in the
+        # exe directory. A change to any of them could affect the cop output
+        # so we include them in the cache hash.
+        source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
+        source_files -= ResultCache.rubocop_required_features # Rely on gem versions
+
+        source_files
+      end
     end
 
     # Return a hash of the options given at invocation, minus the ones that have
@@ -219,19 +224,13 @@ module RuboCop
       options.to_s.gsub(/[^a-z]+/i, '_')
     end
 
-    # The external dependency checksums are cached per RuboCop team so that
-    # the checksums don't need to be recomputed for each file.
-    def team_checksum(team)
-      @checksum_by_team ||= {}.compare_by_identity
-      @checksum_by_team[team] ||= team.external_dependency_checksum
-    end
-
     # We combine team and options into a single "context" checksum to avoid
     # making file names that are too long for some filesystems to handle.
     # This context is for anything that's not (1) the RuboCop executable
     # checksum or (2) the inspected file checksum.
     def context_checksum(team, options)
-      Digest::SHA1.hexdigest([team_checksum(team), relevant_options_digest(options)].join)
+      keys = [team.external_dependency_checksum, relevant_options_digest(options)]
+      Digest::SHA1.hexdigest(keys.join)
     end
   end
 end

data/lib/rubocop/rspec/cop_helper.rb

@@ -6,9 +6,25 @@ require 'tempfile'
 module CopHelper
   extend RSpec::SharedContext
 
-  let(:ruby_version) { RuboCop::TargetRuby::DEFAULT_VERSION }
+  let(:ruby_version) do
+    # The minimum version Prism can parse is 3.3.
+    ENV['PARSER_ENGINE'] == 'parser_prism' ? 3.3 : RuboCop::TargetRuby::DEFAULT_VERSION
+  end
+  let(:parser_engine) do
+    # The maximum version Parser can correctly parse is 3.3.
+    ruby_version >= 3.4 ? :parser_prism : ENV.fetch('PARSER_ENGINE', :parser_whitequark).to_sym
+  end
   let(:rails_version) { false }
 
+  before(:all) do
+    next if ENV['RUBOCOP_CORE_DEVELOPMENT']
+
+    plugins = Gem.loaded_specs.filter_map do |feature_name, feature_specification|
+      feature_name if feature_specification.metadata['default_lint_roller_plugin']
+    end
+    RuboCop::Plugin.integrate_plugins(RuboCop::Config.new, plugins)
+  end
+
   def inspect_source(source, file = nil)
     RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
     RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
@@ -28,7 +44,9 @@ module CopHelper
       file = file.path
     end
 
-    processed_source = RuboCop::ProcessedSource.new(source, ruby_version, file)
+    processed_source = RuboCop::ProcessedSource.new(
+      source, ruby_version, file, parser_engine: parser_engine
+    )
     processed_source.config = configuration
     processed_source.registry = registry
     processed_source

data/lib/rubocop/rspec/expect_offense.rb

@@ -72,9 +72,15 @@ module RuboCop
     #
     #   expect_no_corrections
     #
-    # If your code has variables of different lengths, you can use `%{foo}`,
-    # `^{foo}`, and `_{foo}` to format your template; you can also abbreviate
-    # offense messages with `[...]`:
+    # If your code has variables of different lengths, you can use the
+    # following markers to format your template by passing the variables as a
+    # keyword arguments:
+    #
+    # - `%{foo}`: Interpolates `foo`
+    # - `^{foo}`: Inserts `'^' * foo.size` for dynamic offense range length
+    # - `_{foo}`: Inserts `' ' * foo.size` for dynamic offense range indentation
+    #
+    # You can also abbreviate offense messages with `[...]`.
     #
     #   %w[raise fail].each do |keyword|
     #     expect_offense(<<~RUBY, keyword: keyword)
@@ -111,6 +117,7 @@ module RuboCop
         source
       end
 
+      # rubocop:disable Metrics/AbcSize
       def expect_offense(source, file = nil, severity: nil, chomp: false, **replacements)
         expected_annotations = parse_annotations(source, **replacements)
         source = expected_annotations.plain_source
@@ -123,10 +130,17 @@ module RuboCop
         expect(actual_annotations).to eq(expected_annotations), ''
         expect(@offenses.map(&:severity).uniq).to eq([severity]) if severity
 
+        # Validate that all offenses have a range that formatters can display
+        expect do
+          @offenses.each { |offense| offense.location.source_line }
+        end.not_to raise_error, 'One of the offenses has a misconstructed range, for ' \
+                                'example if the offense is on line 1 and the source is empty'
+
         @offenses
       end
+      # rubocop:enable Metrics/AbcSize
 
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
       def expect_correction(correction, loop: true, source: nil)
         if source
           expected_annotations = parse_annotations(source, raise_error: false)
@@ -148,7 +162,6 @@ module RuboCop
 
           break corrected_source unless loop
           break corrected_source if @last_corrector.empty?
-          break corrected_source if corrected_source == @processed_source.buffer.source
 
           if iteration > RuboCop::Runner::MAX_ITERATIONS
             raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
@@ -162,26 +175,31 @@ module RuboCop
         raise 'Expected correction but no corrections were made' if new_source == source
 
         expect(new_source).to eq(correction)
+        expect(@processed_source).to be_valid_syntax, 'Expected correction to be valid syntax'
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def expect_no_corrections
         raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
 
         return if @last_corrector.empty?
 
-        # In order to print a nice diff, e.g. what source got corrected to,
-        # we need to run the actual corrections
-
+        # This is just here for a pretty diff if the source actually got changed
         new_source = @last_corrector.rewrite
-
         expect(new_source).to eq(@processed_source.buffer.source)
+
+        # There is an infinite loop if a corrector is present that did not make
+        # any changes. It will cause the same offense/correction on the next loop.
+        raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [@offenses])
       end
 
       def expect_no_offenses(source, file = nil)
         offenses = inspect_source(source, file)
 
-        expected_annotations = AnnotatedSource.parse(source)
+        # Since source given `expect_no_offenses` does not have annotations, we do not need to parse
+        # for them, and can just build an `AnnotatedSource` object from the source lines.
+        # This also prevents treating source lines that begin with a caret as an annotation.
+        expected_annotations = AnnotatedSource.new(source.each_line.to_a, [])
         actual_annotations = expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
@@ -212,7 +230,8 @@ module RuboCop
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) /.freeze
+        # Ignore escaped carets, don't treat as annotations
+        ANNOTATION_PATTERN = /\A\s*((?<!\\)\^+|\^{}) ?/.freeze
         ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers