rubocop 1.57.1 → 1.81.6

data/lib/rubocop/lsp/stdin_runner.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Originally lifted from:
+    # https://github.com/Shopify/ruby-lsp/blob/8d4c17efce4e8ecc8e7c557ab2981db6b22c0b6d/lib/ruby_lsp/requests/support/rubocop_runner.rb#L20
+    # @api private
+    class StdinRunner < RuboCop::Runner
+      class ConfigurationError < StandardError; end
+
+      attr_reader :offenses, :config_for_working_directory
+
+      DEFAULT_RUBOCOP_OPTIONS = {
+        stderr: true,
+        force_exclusion: true,
+        formatters: ['RuboCop::Formatter::BaseFormatter'],
+        raise_cop_error: true,
+        todo_file: nil,
+        todo_ignore_files: []
+      }.freeze
+
+      def initialize(config_store)
+        @options = {}
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        @config_for_working_directory = config_store.for_pwd
+
+        super(@options, config_store)
+      end
+
+      def run(path, contents, options, prism_result: nil)
+        @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
+        @options[:stdin] = contents
+
+        @prism_result = prism_result
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        super([path])
+
+        raise Interrupt if aborting?
+      end
+
+      def formatted_source
+        @options[:stdin]
+      end
+
+      private
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+    end
+  end
+end

data/lib/rubocop/lsp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The RuboCop's built-in LSP module.
+  module LSP
+    module_function
+
+    # Returns true when LSP is enabled, false when disabled.
+    #
+    # @return [Boolean]
+    def enabled?
+      @enabled ||= false
+    end
+
+    # Enable LSP.
+    #
+    # @return [void]
+    def enable
+      @enabled = true
+    end
+
+    # Disable LSP.
+    #
+    # @return [void]
+    def disable(&block)
+      if block
+        original = @enabled
+        @enabled = false
+        yield
+        @enabled = original
+      else
+        @enabled = false
+      end
+    end
+  end
+end

data/lib/rubocop/magic_comment.rb

@@ -80,13 +80,13 @@ module RuboCop
 
     # Expose the `frozen_string_literal` value coerced to a boolean if possible.
     #
-    # @return [Boolean] if value is `true` or `false`
+    # @return [Boolean] if value is `true` or `false` in any case
     # @return [nil] if frozen_string_literal comment isn't found
     # @return [String] if comment is found but isn't true or false
     def frozen_string_literal
       return unless (setting = extract_frozen_string_literal)
 
-      case setting
+      case setting.downcase
       when 'true'  then true
       when 'false' then false
       else
@@ -193,6 +193,10 @@ module RuboCop
       SEPARATOR = ';'
       OPERATOR  = ':'
 
+      def new_frozen_string_literal(value)
+        "# -*- frozen_string_literal: #{value} -*-"
+      end
+
       private
 
       def extract_frozen_string_literal
@@ -268,13 +272,17 @@ module RuboCop
 
       # Rewrite the comment without a given token type
       def without(type)
-        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/)
+        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/io)
           ''
         else
           @comment
         end
       end
 
+      def new_frozen_string_literal(value)
+        "# frozen_string_literal: #{value}"
+      end
+
       private
 
       # Extract `frozen_string_literal`.
@@ -283,7 +291,7 @@ module RuboCop
       # is the only text in the comment.
       #
       # Case-insensitive and dashes/underscores are acceptable.
-      # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138
+      # @see https://github.com/ruby/ruby/blob/78b95b49f8/parse.y#L7134-L7138
       def extract_frozen_string_literal
         extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
       end

data/lib/rubocop/options.rb

@@ -95,6 +95,7 @@ module RuboCop
         option(opts, '--ignore-unrecognized-cops')
         option(opts, '--force-default-config')
         option(opts, '-s', '--stdin FILE')
+        option(opts, '--editor-mode')
         option(opts, '-P', '--[no-]parallel')
         option(opts, '--raise-cop-error')
         add_severity_option(opts)
@@ -242,6 +243,7 @@ module RuboCop
         option(opts, '--init')
         option(opts, '-c', '--config FILE')
         option(opts, '-d', '--debug')
+        option(opts, '--plugin FILE') { |f| plugin_feature(f) }
         option(opts, '-r', '--require FILE') { |f| require_feature(f) }
         option(opts, '--[no-]color')
         option(opts, '-v', '--version')
@@ -298,11 +300,25 @@ module RuboCop
       long_opt[2..].sub('[no-]', '').sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
 
-    def require_feature(file)
-      # If any features were added on the CLI from `--require`,
+    def plugin_feature(file)
+      # If any features were added on the CLI from `--plugin`,
       # add them to the config.
-      ConfigLoader.add_loaded_features(file)
-      require file
+      ConfigLoaderResolver.new.resolve_plugins(Config.new, file)
+    end
+
+    def require_feature(file)
+      if Plugin.plugin_capable?(file)
+        # NOTE: Compatibility for before plugins style.
+        warn Rainbow(<<~MESSAGE).yellow
+          #{file} gem supports plugin, use `--plugin` instead of `--require`.
+        MESSAGE
+        plugin_feature(file)
+      else
+        # If any features were added on the CLI from `--require`,
+        # add them to the config.
+        require file
+        ConfigLoader.add_loaded_features(file)
+      end
     end
   end
 
@@ -364,15 +380,12 @@ module RuboCop
         raise OptionArgumentError, '-C/--cache argument must be true or false'
       end
 
-      if display_only_fail_level_offenses_with_autocorrect?
-        raise OptionArgumentError, '--autocorrect cannot be used with ' \
-                                   '--display-only-fail-level-offenses.'
-      end
       validate_auto_gen_config
       validate_autocorrect
       validate_display_only_failed
       validate_display_only_failed_and_display_only_correctable
       validate_display_only_correctable_and_autocorrect
+      validate_lsp_and_editor_mode
       disable_parallel_when_invalid_option_combo
 
       return if incompatible_options.size <= 1
@@ -399,7 +412,7 @@ module RuboCop
       return if @options[:format] == 'junit'
 
       raise OptionArgumentError,
-            format('--display-only-failed can only be used together with --format junit.')
+            '--display-only-failed can only be used together with --format junit.'
     end
 
     def validate_display_only_correctable_and_autocorrect
@@ -417,7 +430,13 @@ module RuboCop
                 !@options.key?(:display_only_safe_correctable)
 
       raise OptionArgumentError,
-            format('--display-only-failed cannot be used together with other display options.')
+            '--display-only-failed cannot be used together with other display options.'
+    end
+
+    def validate_lsp_and_editor_mode
+      return if !@options.key?(:lsp) || !@options.key?(:editor_mode)
+
+      raise OptionArgumentError, 'Do not specify `--editor-mode` as it is redundant in `--lsp`.'
     end
 
     def validate_autocorrect
@@ -431,7 +450,7 @@ module RuboCop
       return unless @options.key?(:disable_uncorrectable)
 
       raise OptionArgumentError,
-            format('--disable-uncorrectable can only be used together with --autocorrect.')
+            '--disable-uncorrectable can only be used together with --autocorrect.'
     end
 
     def disable_parallel_when_invalid_option_combo
@@ -460,10 +479,6 @@ module RuboCop
         (@options[:only] & %w[Lint/RedundantCopDisableDirective RedundantCopDisableDirective]).any?
     end
 
-    def display_only_fail_level_offenses_with_autocorrect?
-      @options.key?(:display_only_fail_level_offenses) && @options.key?(:autocorrect)
-    end
-
     def except_syntax?
       @options.key?(:except) && (@options[:except] & %w[Lint/Syntax Syntax]).any?
     end
@@ -503,6 +518,7 @@ module RuboCop
       only_guide_cops:                  ['Run only cops for rules that link to a',
                                          'style guide.'],
       except:                           'Exclude the given cop(s).',
+      plugin:                           'Load a RuboCop plugin.',
       require:                          'Require Ruby file.',
       config:                           'Specify configuration file.',
       auto_gen_config:                  ['Generate a configuration file acting as a',
@@ -541,8 +557,8 @@ module RuboCop
       only_recognized_file_types:       ['Inspect files given on the command line only if',
                                          'they are listed in `AllCops/Include` parameters',
                                          'of user configuration or default configuration.'],
-      ignore_disable_comments:          ['Run cops even when they are disabled locally',
-                                         'by a `rubocop:disable` directive.'],
+      ignore_disable_comments:          ['Report offenses even if they have been manually disabled',
+                                         'with a `rubocop:disable` or `rubocop:todo` directive.'],
       ignore_parent_exclusion:          ['Prevent from inheriting `AllCops/Exclude` from',
                                          'parent folders.'],
       ignore_unrecognized_cops:         ['Ignore unrecognized cops or departments in the config.'],
@@ -572,13 +588,14 @@ module RuboCop
                                          'cops. Only valid for --format junit.'],
       display_only_fail_level_offenses:
                                         ['Only output offense messages at',
-                                         'the specified --fail-level or above'],
+                                         'the specified --fail-level or above.'],
       display_only_correctable:         ['Only output correctable offense messages.'],
       display_only_safe_correctable:    ['Only output safe-correctable offense messages',
                                          'when combined with --display-only-correctable.'],
       show_cops:                        ['Shows the given cops, or all cops by',
                                          'default, and their configurations for the',
-                                         'current directory.'],
+                                         'current directory.',
+                                         'You can use `*` as a wildcard.'],
       show_docs_url:                    ['Display url to documentation for the given',
                                          'cops, or base url by default.'],
       fail_fast:                        ['Inspect files in order of modification',
@@ -614,9 +631,13 @@ module RuboCop
       version:                          'Display version.',
       verbose_version:                  'Display verbose version.',
       parallel:                         ['Use available CPUs to execute inspection in',
-                                         'parallel. Default is true.'],
+                                         'parallel. Default is true.',
+                                         'You can specify the number of parallel processes using',
+                                         'the $PARALLEL_PROCESSOR_COUNT environment variable.'],
       stdin:                            ['Pipe source from STDIN, using FILE in offense',
                                          'reports. This is useful for editor integration.'],
+      editor_mode:                      ['Optimize real-time feedback in editors,',
+                                         'adjusting behaviors for editing experience.'],
       init:                             'Generate a .rubocop.yml file in the current directory.',
       server:                           ['If a server process has not been started yet, start',
                                          'the server process and execute inspection with server.',
@@ -633,8 +654,8 @@ module RuboCop
       raise_cop_error:                  ['Raise cop-related errors with cause and location.',
                                          'This is used to prevent cops from failing silently.',
                                          'Default is false.'],
-      profile:                          'Profile rubocop',
-      memory:                           'Profile rubocop memory usage'
+      profile:                          'Profile rubocop.',
+      memory:                           'Profile rubocop memory usage.'
     }.freeze
   end
   # rubocop:enable Metrics/ModuleLength

data/lib/rubocop/path_util.rb

@@ -28,23 +28,30 @@ module RuboCop
         end
     end
 
+    def remote_file?(uri)
+      uri.start_with?('http://', 'https://')
+    end
+
     SMART_PATH_CACHE = {} # rubocop:disable Style/MutableConstant
     private_constant :SMART_PATH_CACHE
 
     def smart_path(path)
-      SMART_PATH_CACHE[path] ||= begin
-        # Ideally, we calculate this relative to the project root.
-        base_dir = Dir.pwd
-
-        if path.start_with? base_dir
-          relative_path(path, base_dir)
+      SMART_PATH_CACHE[path] ||=
+        if path.is_a?(RemoteConfig)
+          path.uri.to_s
         else
-          path
+          # Ideally, we calculate this relative to the project root.
+          base_dir = Dir.pwd
+
+          if path.start_with? base_dir
+            relative_path(path, base_dir)
+          else
+            path
+          end
         end
-      end
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     def match_path?(pattern, path)
       case pattern
       when String
@@ -52,6 +59,10 @@ module RuboCop
           if pattern == path
             true
           elsif glob?(pattern)
+            # File name matching doesn't really work with relative patterns that start with "..". We
+            # get around that problem by converting the pattern to an absolute path.
+            pattern = File.expand_path(pattern) if pattern.start_with?('..')
+
             File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
           end
 
@@ -66,7 +77,7 @@ module RuboCop
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
     # Returns true for an absolute Unix or Windows path.
     def absolute?(path)

data/lib/rubocop/pending_cops_reporter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Reports information about pending cops that are not explicitly configured.
+  #
+  # This class is responsible for displaying warnings when new cops have been added to RuboCop
+  # but have not yet been enabled or disabled in the user's configuration.
+  # It provides a centralized way to determine whether such warnings should be shown,
+  # based on global flags or configuration settings.
+  class PendingCopsReporter
+    class << self
+      PENDING_BANNER = <<~BANNER
+        The following cops were added to RuboCop, but are not configured. Please set Enabled to either `true` or `false` in your `.rubocop.yml` file.
+
+        Please also note that you can opt-in to new cops by default by adding this to your config:
+          AllCops:
+            NewCops: enable
+      BANNER
+
+      attr_accessor :disable_pending_cops, :enable_pending_cops
+
+      def warn_if_needed(config)
+        return if possible_new_cops?(config)
+
+        pending_cops = pending_cops_only_qualified(config.pending_cops)
+        warn_on_pending_cops(pending_cops) unless pending_cops.empty?
+      end
+
+      private
+
+      def pending_cops_only_qualified(pending_cops)
+        pending_cops.select { |cop| Cop::Registry.qualified_cop?(cop.name) }
+      end
+
+      def possible_new_cops?(config)
+        disable_pending_cops || enable_pending_cops ||
+          config.disabled_new_cops? || config.enabled_new_cops?
+      end
+
+      def warn_on_pending_cops(pending_cops)
+        warn Rainbow(PENDING_BANNER).yellow
+
+        pending_cops.each { |cop| warn_pending_cop cop }
+
+        warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
+      end
+
+      def warn_pending_cop(cop)
+        version = cop.metadata['VersionAdded'] || 'N/A'
+
+        warn Rainbow("#{cop.name}: # new in #{version}").yellow
+        warn Rainbow('  Enabled: true').yellow
+      end
+    end
+  end
+end

data/lib/rubocop/plugin/configuration_integrator.rb

@@ -0,0 +1,143 @@
+# 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
+
+              ConfigLoader.merge_with_default(plugin_config, plugin_config_path)
+            end
+          end
+        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 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
+        # rubocop:enable Metrics/AbcSize
+
+        # 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