rubocop 1.71.1 → 1.92.1

data/lib/rubocop/lsp/runtime.rb

@@ -17,45 +17,96 @@ module RuboCop
     # Runtime for Language Server Protocol of RuboCop.
     # @api private
     class Runtime
-      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode, :raise_cop_error
+
+      # Without `lsp_mode`, offenses keep the locations and messages the
+      # command line gives them, rather than the ones meant for an editor.
+      def initialize(config_store, lsp_mode: true)
+        RuboCop::LSP.enable if lsp_mode
 
-      def initialize(config_store)
         @runner = RuboCop::Lsp::StdinRunner.new(config_store)
-        @cop_registry = RuboCop::Cop::Registry.global.to_h
 
         @safe_autocorrect = true
         @lint_mode = false
         @layout_mode = false
+        @raise_cop_error = true
       end
 
-      def format(path, text, command:)
+      def format(path, text, command:, prism_result: nil, options: {})
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
                            else
                              @safe_autocorrect
                            end
 
-        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
-        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
+        formatting_options = {
+          autocorrect: true, safe_autocorrect: safe_autocorrect, raise_cop_error: @raise_cop_error
+        }.merge(call_options(options))
 
-        @runner.run(path, text, formatting_options)
+        @runner.run(path, text, formatting_options, prism_result: prism_result)
         @runner.formatted_source
       end
 
-      def offenses(path, text, document_encoding = nil)
-        diagnostic_options = {}
-        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
+      def reset_project_index
+        @runner.reset_project_index
+      end
 
-        @runner.run(path, text, diagnostic_options)
-        @runner.offenses.map do |offense|
-          Diagnostic.new(
-            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
-          ).to_lsp_diagnostic(@runner.config_for_working_directory)
+      def offenses(path, text, document_encoding = nil, prism_result: nil)
+        found = raw_offenses(path, text, prism_result: prism_result)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
+        found.map do |offense|
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
         end
       end
 
+      # The offenses before they are converted to LSP diagnostics, for callers
+      # that do not speak LSP.
+      def raw_offenses(path, text, prism_result: nil, options: {})
+        diagnostic_options = { raise_cop_error: @raise_cop_error }.merge(call_options(options))
+
+        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        @runner.offenses
+      end
+
+      # The offenses the last `format` found but didn't correct, located in the
+      # source it returned.
+      def uncorrected_offenses
+        @runner.offenses.reject(&:corrected?)
+      end
+
+      # What went wrong in the last run. Cop errors only end up here when
+      # `raise_cop_error` is off; otherwise they are raised.
+      def errors
+        @runner.errors
+      end
+
+      def warnings
+        @runner.warnings
+      end
+
       private
 
+      def build_diagnostic(offense, path, document_encoding, processed_source, config)
+        Diagnostic.new(
+          document_encoding,
+          offense,
+          path,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
+          processed_source
+        ).to_lsp_diagnostic(config)
+      end
+
+      # What a caller adds for one call, such as `only` and `except` to select
+      # the cops, or `editing` to hold back the corrections of cops with
+      # `AutoCorrect: contextual`, as LSP mode does. Without `only`, the cops
+      # are the departments a lint or layout mode limits the server to.
+      def call_options(options)
+        return options if options[:only] || !(@lint_mode || @layout_mode)
+
+        options.merge(only: config_only_options)
+      end
+
       def config_only_options
         only_options = []
         only_options << 'Lint' if @lint_mode

data/lib/rubocop/lsp/server.rb

@@ -22,8 +22,6 @@ module RuboCop
       def initialize(config_store)
         $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
 
-        RuboCop::LSP.enable
-
         @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
         @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
         @runtime = RuboCop::LSP::Runtime.new(config_store)
@@ -63,6 +61,10 @@ module RuboCop
         @runtime.layout_mode = options[:layout_mode]
       end
 
+      def reset_project_index
+        @runtime.reset_project_index
+      end
+
       def stop(&block)
         at_exit(&block) if block
         exit

data/lib/rubocop/lsp/stdin_runner.rb

@@ -17,13 +17,12 @@ module RuboCop
     class StdinRunner < RuboCop::Runner
       class ConfigurationError < StandardError; end
 
-      attr_reader :offenses, :config_for_working_directory
+      attr_reader :offenses, :config_for_working_directory, :processed_source
 
       DEFAULT_RUBOCOP_OPTIONS = {
         stderr: true,
         force_exclusion: true,
         formatters: ['RuboCop::Formatter::BaseFormatter'],
-        raise_cop_error: true,
         todo_file: nil,
         todo_ignore_files: []
       }.freeze
@@ -40,11 +39,20 @@ module RuboCop
         super(@options, config_store)
       end
 
-      # rubocop:disable Metrics/MethodLength
-      def run(path, contents, options)
+      def run(path, contents, options, prism_result: nil)
+        # The cops mobilized for a configuration are cached, which only holds while
+        # every run asks for the same ones.
+        selection = options.values_at(:only, :except)
+        unless selection == @cop_selection
+          forget_mobilized_cops
+          @cop_selection = selection
+        end
         @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
         @options[:stdin] = contents
 
+        @prism_result = prism_result
+        @processed_source = nil
+
         @offenses = []
         @warnings = []
         @errors = []
@@ -52,32 +60,43 @@ module RuboCop
         super([path])
 
         raise Interrupt if aborting?
-      rescue RuboCop::Runner::InfiniteCorrectionLoop => e
-        if defined?(::RubyLsp::Requests::Formatting::Error)
-          raise ::RubyLsp::Requests::Formatting::Error, e.message
-        end
-
-        raise e
-      rescue RuboCop::ValidationError => e
-        raise ConfigurationError, e.message
-      rescue StandardError => e
-        if defined?(::RubyLsp::Requests::Formatting::Error)
-          raise ::RubyLsp::Requests::Support::InternalRuboCopError, e
-        end
-
-        raise e
       end
-      # rubocop:enable Metrics/MethodLength
 
       def formatted_source
         @options[:stdin]
       end
 
+      # Drop the cached project index so the next run rebuilds it. Called when a
+      # file is saved or a watched file changes, i.e. when the on-disk state the
+      # index is derived from may have changed.
+      def reset_project_index
+        @project_index = nil
+        @project_index_built = false
+      end
+
       private
 
+      # The project index is built from files on disk, not from the in-memory
+      # buffer, so it does not change while the user is typing. Build it once and
+      # reuse it across runs instead of re-walking and re-indexing the whole
+      # project on every request; `reset_project_index` drops the cache when the
+      # on-disk state changes.
+      def build_project_index(target_files)
+        return if @project_index_built
+
+        super
+        @project_index_built = true
+      end
+
       def file_finished(_file, offenses)
         @offenses = offenses
       end
+
+      def do_inspection_loop(file, source = nil)
+        processed_source, offenses = super
+        @processed_source = processed_source
+        [processed_source, offenses]
+      end
     end
   end
 end

data/lib/rubocop/lsp.rb

@@ -26,8 +26,11 @@ module RuboCop
       if block
         original = @enabled
         @enabled = false
-        yield
-        @enabled = original
+        begin
+          yield
+        ensure
+          @enabled = original
+        end
       else
         @enabled = false
       end

data/lib/rubocop/magic_comment.rb

@@ -11,6 +11,8 @@ module RuboCop
     KEYWORDS = {
       encoding: '(?:en)?coding',
       frozen_string_literal: 'frozen[_-]string[_-]literal',
+      rbs_inline: 'rbs_inline',
+      warn_indent: 'warn[_-]indent',
       shareable_constant_value: 'shareable[_-]constant[_-]value',
       typed: 'typed'
     }.freeze
@@ -36,6 +38,8 @@ module RuboCop
     def any?
       frozen_string_literal_specified? ||
         encoding_specified? ||
+        rbs_inline_specified? ||
+        warn_indent_specified? ||
         shareable_constant_value_specified? ||
         typed_specified?
     end
@@ -60,6 +64,10 @@ module RuboCop
       [true, false].include?(frozen_string_literal)
     end
 
+    def valid_rbs_inline_value?
+      %w[enabled disabled].include?(extract_rbs_inline_value)
+    end
+
     def valid_shareable_constant_value?
       %w[none literal experimental_everything experimental_copy].include?(shareable_constant_value)
     end
@@ -71,6 +79,13 @@ module RuboCop
       specified?(frozen_string_literal)
     end
 
+    # Was a warn_indent specified?
+    #
+    # @return [Boolean]
+    def warn_indent_specified?
+      specified?(warn_indent)
+    end
+
     # Was a shareable_constant_value specified?
     #
     # @return [Boolean]
@@ -94,6 +109,13 @@ module RuboCop
       end
     end
 
+    # Expose the `warn_indent` value.
+    #
+    # @return [String] for warn_indent config
+    def warn_indent
+      extract_warn_indent
+    end
+
     # Expose the `shareable_constant_value` value coerced to a boolean if possible.
     #
     # @return [String] for shareable_constant_value config
@@ -105,6 +127,10 @@ module RuboCop
       specified?(encoding)
     end
 
+    def rbs_inline_specified?
+      valid_rbs_inline_value?
+    end
+
     # Was the Sorbet `typed` sigil specified?
     #
     # @return [Boolean]
@@ -193,12 +219,23 @@ module RuboCop
       SEPARATOR = ';'
       OPERATOR  = ':'
 
+      def new_frozen_string_literal(value)
+        "# -*- frozen_string_literal: #{value} -*-"
+      end
+
       private
 
       def extract_frozen_string_literal
         match(KEYWORDS[:frozen_string_literal])
       end
 
+      # Emacs comments cannot specify RBS::inline behavior.
+      def extract_rbs_inline_value; end
+
+      def extract_warn_indent
+        match(KEYWORDS[:warn_indent])
+      end
+
       def extract_shareable_constant_value
         match(KEYWORDS[:shareable_constant_value])
       end
@@ -238,6 +275,12 @@ module RuboCop
       # Vim comments cannot specify frozen string literal behavior.
       def frozen_string_literal; end
 
+      # Vim comments cannot specify RBS::inline behavior.
+      def extract_rbs_inline_value; end
+
+      # Vim comments cannot specify indentation warning behavior.
+      def warn_indent; end
+
       # Vim comments cannot specify shareable constant values behavior.
       def shareable_constant_value; end
 
@@ -275,6 +318,10 @@ module RuboCop
         end
       end
 
+      def new_frozen_string_literal(value)
+        "# frozen_string_literal: #{value}"
+      end
+
       private
 
       # Extract `frozen_string_literal`.
@@ -288,6 +335,14 @@ module RuboCop
         extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
       end
 
+      def extract_rbs_inline_value
+        extract(/\A\s*#\s*#{KEYWORDS[:rbs_inline]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_warn_indent
+        extract(/\A\s*#\s*#{KEYWORDS[:warn_indent]}:\s*#{TOKEN}\s*\z/io)
+      end
+
       def extract_shareable_constant_value
         extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
       end

data/lib/rubocop/mcp/autocorrection_request.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module MCP
+    # What an autocorrection request asks for, shared by every file it corrects.
+    # The keywords are the tool's arguments, so an unknown one is refused.
+    # @api private
+    class AutocorrectionRequest
+      PROPERTIES = {
+        safety: { type: 'boolean' },
+        contextual: { type: 'boolean' },
+        dry_run: { type: 'boolean' },
+        max_offenses_per_cop: { type: 'integer', minimum: 1 }
+      }.freeze
+
+      # The offenses left over come back after the files are written, so they're
+      # capped unless the agent asks otherwise: a result too big for the client
+      # would hide what was done.
+      DEFAULT_MAX_OFFENSES_PER_COP = 5
+
+      attr_reader :scope, :limit
+
+      def initialize(scope, safety: true, contextual: false, dry_run: false,
+                     max_offenses_per_cop: DEFAULT_MAX_OFFENSES_PER_COP)
+        @scope = scope
+        @safety = safety
+        @contextual = contextual
+        @dry_run = dry_run
+        @limit = OffenseLimit.new(max_offenses_per_cop)
+      end
+
+      def dry_run?
+        @dry_run
+      end
+
+      # The options `LSP::Runtime#format` takes to apply the corrections
+      # `safety` and `contextual` allow, from the cops the scope selects.
+      def format_options
+        command = @safety ? 'rubocop.formatAutocorrects' : 'rubocop.formatAutocorrectsAll'
+        { command: command, options: runtime_options }
+      end
+
+      # The options the LSP runtime takes for each call the request makes.
+      # Cops with `AutoCorrect: contextual` hold back corrections that get in
+      # the way of code still being written, such as removing a variable that
+      # is about to be used, so an agent that is done editing has to ask for them.
+      def runtime_options
+        { **@scope.cop_options, editing: !@contextual }
+      end
+    end
+  end
+end

data/lib/rubocop/mcp/explain_tool.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module MCP
+    # The `rubocop_explain` tool: what cops do, as `--explain` prints it.
+    # @api private
+    class ExplainTool
+      include RuboCop::CLI::Command::CopNames
+
+      DESCRIPTION =
+        'Explain what cops do: the problem each one targets, bad and good examples, ' \
+        'its configuration as this project resolves it, and whether it autocorrects. ' \
+        'Takes cop names as offenses report them, such as `Style/StringLiterals`. ' \
+        'Pass the `path` of a file to see the configuration that applies to it.'
+      INPUT_SCHEMA = {
+        properties: {
+          cop_names: { type: 'array', items: { type: 'string' }, minItems: 1 },
+          path: { type: 'string' }
+        },
+        required: ['cop_names'],
+        additionalProperties: false
+      }.freeze
+      ANNOTATIONS = {
+        title: "RuboCop's cop explanation", destructive_hint: false, idempotent_hint: true,
+        open_world_hint: false, read_only_hint: true
+      }.freeze
+
+      def initialize(config_store)
+        @config_store = config_store
+      end
+
+      # The tool's block does not run in this instance, so it reaches
+      # `explain` through a method object it closes over.
+      def to_tool
+        explain = method(:explain)
+
+        ::MCP::Tool.define(
+          name: 'rubocop_explain',
+          description: DESCRIPTION,
+          input_schema: INPUT_SCHEMA,
+          annotations: ANNOTATIONS
+        ) do |cop_names:, path: nil|
+          ::MCP::Tool::Response.new([{ type: 'text', text: explain.call(cop_names, path) }])
+        rescue RuboCop::Error => e
+          ::MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+        end
+      end
+
+      private
+
+      # Explains the cops it recognizes and then names the ones it does not, as
+      # `--explain` does, so a typo does not cost the explanations asked for
+      # alongside it. The configuration is loaded first, since that is what
+      # registers the cops of any plugins it names.
+      def explain(cop_names, path)
+        config = path ? @config_store.for_file(path) : @config_store.for_pwd
+        explanations = known_cop_classes(cop_names).map do |cop_class|
+          Cop::CopExplanation.new(cop_class, config).to_s
+        end
+        validate_cop_names!(cop_names)
+
+        explanations.join("\n\n")
+      rescue IncorrectCopNameError => e
+        raise RuboCop::Error, [*explanations, e.message].join("\n\n")
+      end
+    end
+  end
+end

data/lib/rubocop/mcp/scope.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module MCP
+    # What a request asks RuboCop to look at: which cops run, as `--only` and
+    # `--except` choose them, and, when checking files, whether to stick to the
+    # ones git says changed, as `--changed` does.
+    # @api private
+    class Scope
+      PROPERTIES = {
+        only: {
+          type: 'array', items: { type: 'string' },
+          description: 'Run only these cops or departments, ' \
+                       'such as `Style/StringLiterals` or `Lint`.'
+        },
+        except: {
+          type: 'array', items: { type: 'string' },
+          description: 'Run every cop except these cops or departments.'
+        },
+        changed: {
+          type: %w[boolean string],
+          description: 'Check only the files git says changed: `true` for changes since the ' \
+                       'last commit, or a revision to compare against, such as `main`.'
+        }
+      }.freeze
+
+      # An empty list would select no cops at all rather than leave the choice
+      # alone, so it counts as no list.
+      #
+      # @raise [RuboCop::Error] for a scope the command line would refuse
+      def initialize(inline:, only: nil, except: nil, changed: nil)
+        @only = only if only&.any?
+        @except = except if except&.any?
+        @changed = changed == true ? ChangedFiles::DEFAULT_REVISION : changed
+        validate(inline)
+      end
+
+      # @return [Hash] the cop selection, among the options the LSP runtime takes
+      def cop_options
+        { only: @only, except: @except }.compact
+      end
+
+      def select_files(files)
+        @changed ? ChangedFiles.new(@changed).filter(files) : files
+      end
+
+      private
+
+      # Refuses what the command line refuses for the same options. Cop names
+      # are left to the runner, which checks them the way `--only` does: short
+      # names allowed, and only once the configuration naming a plugin's cops
+      # has been loaded.
+      def validate(inline)
+        raise Error, '`changed` only applies when checking files.' if inline && @changed
+        raise Error, '`changed` takes `true` or a git revision.' if @changed == ''
+
+        validator = OptionsValidator.new(cop_options)
+        if validator.only_includes_redundant_disable?
+          raise Error, 'Lint/RedundantCopDisableDirective cannot be used with `only`.'
+        end
+        raise Error, 'Syntax checking cannot be turned off.' if validator.except_syntax?
+      end
+    end
+  end
+end