rubocop 1.71.1 → 1.92.0

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'lint_roller/context'
+require_relative 'not_supported_error'
+
+module RuboCop
+  module Plugin
+    # A class for integrating plugin configurations into RuboCop.
+    # Handles configuration merging, validation, and compatibility for plugins.
+    # @api private
+    class ConfigurationIntegrator
+      class << self
+        def integrate_plugins_into_rubocop_config(rubocop_config, plugins)
+          default_config = ConfigLoader.default_configuration
+          runner_context = create_context(rubocop_config)
+
+          validate_plugins!(plugins, runner_context)
+
+          plugin_config = combine_rubocop_configs(default_config, runner_context, plugins).to_h
+
+          merge_plugin_config_into_all_cops!(default_config, plugin_config)
+          merge_plugin_config_into_default_config!(default_config, plugin_config)
+        end
+
+        private
+
+        def create_context(rubocop_config)
+          LintRoller::Context.new(
+            runner: :rubocop,
+            runner_version: Version.version,
+            engine: :rubocop,
+            engine_version: Version.version,
+            target_ruby_version: rubocop_config.target_ruby_version
+          )
+        end
+
+        def validate_plugins!(plugins, runner_context)
+          unsupported_plugins = plugins.reject { |plugin| plugin.supported?(runner_context) }
+          return if unsupported_plugins.none?
+
+          raise Plugin::NotSupportedError, unsupported_plugins
+        end
+
+        def combine_rubocop_configs(default_config, runner_context, plugins)
+          fake_out_rubocop_default_configuration(default_config) do |fake_config|
+            all_cop_keys_configured_by_plugins = []
+
+            plugins.reduce(fake_config) do |combined_config, plugin|
+              RuboCop::ConfigLoader.instance_variable_set(:@default_configuration, combined_config)
+
+              print 'Plugin ' if ConfigLoader.debug
+
+              plugin_config, plugin_config_path = load_plugin_rubocop_config(plugin, runner_context)
+
+              plugin_config['AllCops'], all_cop_keys_configured_by_plugins = merge_all_cop_settings(
+                combined_config['AllCops'], plugin_config['AllCops'],
+                all_cop_keys_configured_by_plugins
+              )
+
+              plugin_config.make_excludes_absolute
+
+              merge_plugin_config_with_default(plugin_config, plugin_config_path)
+            end
+          end
+        end
+
+        # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin
+        # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` carries
+        # such keys into each subsequent plugin's config, where `unset_nil: true` would
+        # delete them from the combined configuration. Preview is left to be applied when
+        # a project configuration is resolved against the defaults.
+        def merge_plugin_config_with_default(plugin_config, plugin_config_path)
+          ConfigLoader.merge_with_default(
+            plugin_config, plugin_config_path, unset_nil: false, resolve_preview: false
+          )
+        end
+
+        def merge_plugin_config_into_all_cops!(rubocop_config, plugin_config)
+          rubocop_config['AllCops'].merge!(plugin_config['AllCops'])
+        end
+
+        def merge_plugin_config_into_default_config!(default_config, plugin_config)
+          plugin_config.each do |key, value|
+            default_config[key] = if default_config[key].is_a?(Hash)
+                                    resolver.merge(default_config[key], value)
+                                  else
+                                    value
+                                  end
+          end
+        end
+
+        def fake_out_rubocop_default_configuration(default_config)
+          orig_default_config = ConfigLoader.instance_variable_get(:@default_configuration)
+
+          result = yield default_config
+
+          ConfigLoader.instance_variable_set(:@default_configuration, orig_default_config)
+
+          result
+        end
+
+        # rubocop:disable-next Metrics/AbcSize
+        def load_plugin_rubocop_config(plugin, runner_context)
+          rules = plugin.rules(runner_context)
+
+          case rules.type
+          when :path
+            [ConfigLoader.load_file(rules.value, check: false), rules.value]
+          when :object
+            path = plugin.method(:rules).source_location[0]
+            [Config.create(rules.value, path, check: true), path]
+          when :error
+            plugin_name = plugin.about&.name || plugin.inspect
+            error_message = rules.value.respond_to?(:message) ? rules.value.message : rules.value
+
+            raise "Plugin `#{plugin_name}' failed to load with error: #{error_message}"
+          end
+        end
+
+        # This is how we ensure "first-in wins": plugins can override AllCops settings that are
+        # set by RuboCop's default configuration, but once a plugin sets an AllCop setting, they
+        # have exclusive first-in-wins rights to that setting.
+        #
+        # The one exception to this are array fields, because we don't want to
+        # overwrite the AllCops defaults but rather munge the arrays (`existing |
+        # new`) to allow plugins to add to the array, for example Include and
+        # Exclude paths and patterns.
+        def merge_all_cop_settings(existing_all_cops, new_all_cops, already_configured_keys)
+          return [existing_all_cops, already_configured_keys] unless new_all_cops.is_a?(Hash)
+
+          combined_all_cops = existing_all_cops.dup
+          combined_configured_keys = already_configured_keys.dup
+
+          new_all_cops.each do |key, value|
+            if combined_all_cops[key].is_a?(Array) && value.is_a?(Array)
+              combined_all_cops[key] |= value
+              combined_configured_keys |= [key]
+            elsif !combined_configured_keys.include?(key)
+              combined_all_cops[key] = value
+              combined_configured_keys << key
+            end
+          end
+
+          [combined_all_cops, combined_configured_keys]
+        end
+
+        def resolver
+          @resolver ||= ConfigLoaderResolver.new
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/load_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Plugin
+    # An exception raised when a plugin fails to load.
+    # @api private
+    class LoadError < Error
+      def initialize(plugin_name)
+        super
+
+        @plugin_name = plugin_name
+      end
+
+      def message
+        <<~MESSAGE
+          Failed to load plugin `#{@plugin_name}` because the corresponding plugin class could not be determined for instantiation.
+          Try upgrading it first (e.g., `bundle update #{@plugin_name}`).
+          If `#{@plugin_name}` is not yet a plugin, use `require: #{@plugin_name}` instead of `plugins: #{@plugin_name}` in your configuration.
+
+          For further assistance, check with the developer regarding the following points:
+          https://docs.rubocop.org/rubocop/plugin_migration_guide.html
+        MESSAGE
+      end
+    end
+  end
+end

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 -- the comment on each key does not wrap
+      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: PathUtil.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/project_index_loader.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Defensive loader for the optional `rubydex` gem.
+  #
+  # When `AllCops/UseProjectIndex` is enabled in the user's configuration, RuboCop builds
+  # a project-wide index using `Rubydex::Graph` and exposes it to cops that opt in.
+  # The gem is intentionally not a runtime dependency; if it is not installed,
+  # or if the running Ruby is older than what `rubydex` supports, RuboCop falls back to
+  # its standard file-local behavior.
+  module ProjectIndexLoader
+    MINIMUM_RUBY_VERSION = '3.2'
+
+    module_function
+
+    # Returns whether the `rubydex` gem can be loaded. The result is memoized
+    # for the lifetime of the process.
+    def available?
+      return @available if defined?(@available)
+
+      @available = supported_ruby? && try_require
+    end
+
+    def supported_ruby?
+      RUBY_VERSION >= MINIMUM_RUBY_VERSION
+    end
+
+    def warn_unavailable
+      return if @warned
+
+      @warned = true
+
+      if supported_ruby?
+        warn Rainbow(<<~MSG).yellow
+          `AllCops/UseProjectIndex` is enabled but the `rubydex` gem is not installed.
+          Analyses that use the project index will be skipped. Add `gem 'rubydex'` to your Gemfile.
+        MSG
+      else
+        warn Rainbow(<<~MSG).yellow
+          `AllCops/UseProjectIndex` is enabled but `rubydex` requires Ruby #{MINIMUM_RUBY_VERSION} or later (current: #{RUBY_VERSION}).
+          Analyses that use the project index will be skipped.
+        MSG
+      end
+    end
+
+    def try_require
+      require 'rubydex'
+      true
+    rescue LoadError
+      false
+    end
+
+    # Builds and resolves a `Rubydex::Graph` for the given file paths. Returns the resolved graph,
+    # or `nil` if the build fails. This is the only place in RuboCop that depends on the concrete
+    # `Rubydex::Graph` API, so callers (e.g. `Runner`) do not need to know which Rubydex classes
+    # or methods are involved.
+    def build_index(paths)
+      graph = Rubydex::Graph.new
+      graph.index_all(paths.map(&:to_s))
+      graph.resolve
+      graph
+    rescue StandardError => e
+      warn Rainbow("rubydex index build failed: #{e.message}. Continuing without it.").yellow
+    end
+
+    # The Ruby source files of every gem in the project's bundle, for
+    # `AllCops/ProjectIndexIncludesGems`. Returns an empty array when RuboCop
+    # does not run inside Bundler, so the option silently degrades to
+    # project-only indexing.
+    def bundled_gem_source_files
+      return [] unless defined?(Bundler) && Bundler::SharedHelpers.in_bundle?
+
+      Bundler.load.specs.flat_map do |spec|
+        Dir.glob(File.join(spec.full_gem_path, 'lib', '**', '*.rb'))
+      end
+    rescue StandardError => e
+      message = "rubydex bundle indexing failed: #{e.message}. Indexing the project only."
+      warn Rainbow(message).yellow
+      []
+    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()
@@ -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 = []
@@ -71,8 +74,8 @@ module RuboCop
 
     def setup_subtasks(name, *args, &task_block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       namespace(name) do
-        # rubocop:todo Naming/InclusiveLanguage
-        task(:auto_correct, *args) do
+        # rubocop:todo-next Naming/InclusiveLanguage -- the deprecated flag spelling is the subject here
+        task(:auto_correct, *args) do |_, task_args|
           require 'rainbow'
           warn Rainbow(
             'rubocop:auto_correct task is deprecated; ' \
@@ -83,7 +86,6 @@ module RuboCop
             perform('--autocorrect')
           end
         end
-        # rubocop:enable Naming/InclusiveLanguage
 
         desc "Autocorrect RuboCop offenses (only when it's safe)."
         task(:autocorrect, *args) do |_, task_args|

data/lib/rubocop/remote_config.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'net/http'
 require 'time'
+require 'uri'
 
 module RuboCop
   # Common methods and behaviors for dealing with remote config files.
@@ -11,13 +11,13 @@ module RuboCop
 
     CACHE_LIFETIME = 24 * 60 * 60
 
-    def initialize(url, base_dir)
+    def initialize(url, cache_root)
       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
+      @cache_root = cache_root
     end
 
     def file
@@ -27,16 +27,17 @@ module RuboCop
         next if response.is_a?(Net::HTTPNotModified)
         next if response.is_a?(SocketError)
 
+        FileUtils.mkdir_p(File.dirname(cache_path))
         File.write(cache_path, response.body)
       end
 
       cache_path
     end
 
-    def inherit_from_remote(file, path)
+    def inherit_from_remote(file)
       new_uri = @uri.dup
       new_uri.path.gsub!(%r{/[^/]*$}, "/#{file.delete_prefix('./')}")
-      RemoteConfig.new(new_uri.to_s, File.dirname(path))
+      RemoteConfig.new(new_uri.to_s, @cache_root)
     end
 
     private
@@ -44,13 +45,16 @@ module RuboCop
     def request(uri = @uri, limit = 10, &block)
       raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
 
+      # Loaded here rather than at the top, since most runs never fetch a remote config.
+      require 'net/http'
+
       http = Net::HTTP.new(uri.hostname, uri.port)
       http.use_ssl = uri.instance_of?(URI::HTTPS)
 
       generate_request(uri) do |request|
-        handle_response(http.request(request), limit, &block)
+        handle_response(http.request(request), uri, limit, &block)
       rescue SocketError => e
-        handle_response(e, limit, &block)
+        handle_response(e, uri, limit, &block)
       end
     end
 
@@ -63,12 +67,12 @@ module RuboCop
       yield request
     end
 
-    def handle_response(response, limit, &block)
+    def handle_response(response, uri, limit, &block)
       case response
       when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
         yield response
       when Net::HTTPRedirection
-        request(URI.parse(response['location']), limit - 1, &block)
+        request(URI.join(uri, response['location']), limit - 1, &block)
       else
         begin
           response.error!
@@ -80,7 +84,7 @@ module RuboCop
     end
 
     def cache_path
-      File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)
+      @cache_path ||= File.expand_path(cache_name_from_uri, @cache_root)
     end
 
     def cache_path_exists?
@@ -97,9 +101,10 @@ module RuboCop
     end
 
     def cache_name_from_uri
-      uri = cloned_url
-      uri.query = nil
-      uri.to_s.gsub!(/[^0-9A-Za-z]/, '-')
+      # The md5 checksum suffix is 37 bytes, so we play it save and
+      # allow 254 bytes total - this should be safe on Linux/macOS/Windows
+      filename = File.basename(@uri.path).gsub(/\.ya?ml\z/i, '').byteslice(0, 217).scrub('')
+      "#{filename}-#{Digest::MD5.hexdigest(@uri.to_s)}.yml"
     end
 
     def cloned_url