rubocop 1.79.2 → 1.87.0

data/lib/rubocop/lsp/disable_comment_edits.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Builds LSP text edits for rubocop:disable comments.
+    # @api private
+    class DisableCommentEdits
+      def initialize(offense:, document_encoding:, processed_source:)
+        @offense = offense
+        @document_encoding = document_encoding
+        @processed_source = processed_source
+      end
+
+      def edits
+        literal_range = multiline_literal_range
+        return block_disable_comments(literal_range) if literal_range
+
+        inline_disable_comment
+      end
+
+      private
+
+      def inline_disable_comment
+        eol = position(@offense.line - 1, @offense.source_line.length, @offense.source_line)
+        [text_edit(eol, inline_comment_text)]
+      end
+
+      def inline_comment_text
+        if @offense.source_line.include?(' # rubocop:disable ')
+          ",#{@offense.cop_name}"
+        else
+          " # rubocop:disable #{@offense.cop_name}"
+        end
+      end
+
+      def block_disable_comments(range)
+        full_line_range = range_by_lines(range)
+        leading_whitespace = full_line_range.source_line[/^\s*/].to_s
+        [
+          disable_edit(full_line_range.first_line, leading_whitespace),
+          enable_edit(full_line_range, leading_whitespace)
+        ]
+      end
+
+      def disable_edit(first_line, leading_whitespace)
+        position = position(first_line - 1, 0, '')
+        text_edit(position, "#{leading_whitespace}# rubocop:disable #{@offense.cop_name}\n")
+      end
+
+      def enable_edit(full_line_range, leading_whitespace)
+        last_line = full_line_range.last_line
+        last_line_text = full_line_range.source_buffer.source_line(last_line)
+        position = position(last_line - 1, last_line_text.length, last_line_text)
+        text_edit(position, "\n#{leading_whitespace}# rubocop:enable #{@offense.cop_name}")
+      end
+
+      def text_edit(position, new_text)
+        range = LanguageServer::Protocol::Interface::Range.new(start: position, end: position)
+        LanguageServer::Protocol::Interface::TextEdit.new(range: range, new_text: new_text)
+      end
+
+      def position(line, utf8_index, line_text)
+        LanguageServer::Protocol::Interface::Position.new(
+          line: line,
+          character: position_character(utf8_index, line_text)
+        )
+      end
+
+      def position_character(utf8_index, line_text)
+        str = line_text[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.length
+        end
+      end
+
+      def multiline_literal_range
+        return unless @processed_source&.ast
+
+        offense_range = @offense.location
+        multiline_ranges&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+      end
+
+      def multiline_ranges
+        @processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
+
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      end
+
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/routes.rb

@@ -51,7 +51,7 @@ module RuboCop
             capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
               document_formatting_provider: true,
               text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
                 open_close: true
               )
             )
@@ -61,9 +61,16 @@ module RuboCop
 
       handle 'initialized' do |_request|
         version = RuboCop::Version::STRING
-        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
-
-        Logger.log("RuboCop #{version} language server#{yjit} initialized, PID #{Process.pid}")
+        # Only one JIT can be enabled at the same time, since YJIT and ZJIT are mutually exclusive.
+        jit = if Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled?
+                '+YJIT'
+              elsif Object.const_defined?('RubyVM::ZJIT') && RubyVM::ZJIT.enabled?
+                '+ZJIT'
+              else
+                ''
+              end
+
+        Logger.log("RuboCop #{version} language server#{jit} initialized, PID #{Process.pid}")
       end
 
       handle 'shutdown' do |request|
@@ -76,7 +83,12 @@ module RuboCop
 
       handle 'textDocument/didChange' do |request|
         params = request[:params]
-        result = diagnostic(params[:textDocument][:uri], params[:contentChanges][0][:text])
+        file_uri = params[:textDocument][:uri]
+        text = @text_cache[file_uri]
+        params[:contentChanges].each do |content|
+          text = change_text(text, content[:text], content[:range])
+        end
+        result = diagnostic(file_uri, text)
         @server.write(result)
       end
 
@@ -198,13 +210,13 @@ module RuboCop
 
         return [] if new_text == text
 
-        [
+        [{
           newText: new_text,
           range: {
             start: { line: 0, character: 0 },
             end: { line: text.count("\n") + 1, character: 0 }
           }
-        ]
+        }]
       end
 
       def diagnostic(file_uri, text)
@@ -219,6 +231,30 @@ module RuboCop
         }
       end
 
+      def change_text(orig_text, text, range)
+        return text unless range
+
+        start_pos = text_pos(orig_text, range[:start])
+        end_pos = text_pos(orig_text, range[:end])
+        text_bin = orig_text.b
+        text_bin[start_pos...end_pos] = text.b
+        text_bin.force_encoding(orig_text.encoding)
+      end
+
+      def text_pos(text, range)
+        line = range[:line]
+        char = range[:character]
+        pos = 0
+        text.each_line.with_index do |l, i|
+          if i == line
+            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
+            return pos
+          end
+          pos += l.bytesize
+        end
+        pos
+      end
+
       def convert_file_uri_to_path(uri)
         URI.decode_www_form_component(uri.delete_prefix('file://'))
       end

data/lib/rubocop/lsp/runtime.rb

@@ -23,7 +23,6 @@ module RuboCop
         RuboCop::LSP.enable
 
         @runner = RuboCop::Lsp::StdinRunner.new(config_store)
-        @cop_registry = RuboCop::Cop::Registry.global.to_h
 
         @safe_autocorrect = true
         @lint_mode = false
@@ -49,15 +48,25 @@ module RuboCop
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
         @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
         @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)
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
         end
       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
+
       def config_only_options
         only_options = []
         only_options << 'Lint' if @lint_mode

data/lib/rubocop/lsp/stdin_runner.rb

@@ -17,7 +17,7 @@ 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,
@@ -40,12 +40,12 @@ module RuboCop
         super(@options, config_store)
       end
 
-      # rubocop:disable Metrics/MethodLength
       def run(path, contents, options, prism_result: nil)
         @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
         @options[:stdin] = contents
 
         @prism_result = prism_result
+        @processed_source = nil
 
         @offenses = []
         @warnings = []
@@ -54,22 +54,7 @@ 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]
@@ -80,6 +65,12 @@ module RuboCop
       def file_finished(_file, offenses)
         @offenses = offenses
       end
+
+      def do_inspection_loop(file)
+        source, offenses = super
+        @processed_source = source
+        [source, offenses]
+      end
     end
   end
 end

data/lib/rubocop/magic_comment.rb

@@ -11,6 +11,7 @@ module RuboCop
     KEYWORDS = {
       encoding: '(?:en)?coding',
       frozen_string_literal: 'frozen[_-]string[_-]literal',
+      rbs_inline: 'rbs_inline',
       shareable_constant_value: 'shareable[_-]constant[_-]value',
       typed: 'typed'
     }.freeze
@@ -36,6 +37,7 @@ module RuboCop
     def any?
       frozen_string_literal_specified? ||
         encoding_specified? ||
+        rbs_inline_specified? ||
         shareable_constant_value_specified? ||
         typed_specified?
     end
@@ -60,6 +62,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
@@ -105,6 +111,10 @@ module RuboCop
       specified?(encoding)
     end
 
+    def rbs_inline_specified?
+      valid_rbs_inline_value?
+    end
+
     # Was the Sorbet `typed` sigil specified?
     #
     # @return [Boolean]
@@ -203,6 +213,9 @@ module RuboCop
         match(KEYWORDS[:frozen_string_literal])
       end
 
+      # Emacs comments cannot specify RBS::inline behavior.
+      def extract_rbs_inline_value; end
+
       def extract_shareable_constant_value
         match(KEYWORDS[:shareable_constant_value])
       end
@@ -242,6 +255,9 @@ 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 shareable constant values behavior.
       def shareable_constant_value; end
 
@@ -296,6 +312,10 @@ 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_shareable_constant_value
         extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
       end

data/lib/rubocop/mcp/server.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+begin
+  require 'mcp'
+
+  required_mcp_version = '0.6.0'
+
+  if Gem::Version.new(required_mcp_version) > Gem::Version.new(MCP::VERSION)
+    # While `mcp` is not a runtime dependency, users may have an outdated version installed.
+    warn <<~MESSAGE
+      Error: `mcp` gem version #{MCP::VERSION} was loaded, but `rubocop --mcp` requires #{required_mcp_version}.
+      - If you're using Bundler and don't yet have `gem 'mcp'` as a dependency, add it now.
+      - If you're using Bundler and already have `gem 'mcp'` as a dependency, update it to the most recent version.
+      - If you don't use Bundler, run `gem update mcp`.
+    MESSAGE
+    exit!
+  end
+rescue LoadError => e
+  raise unless e.path == 'mcp'
+
+  warn <<~MESSAGE
+    Error: Unable to load `mcp` gem. Add `gem 'mcp', '~> 0.6'` to your Gemfile, or run `gem install mcp`.
+  MESSAGE
+
+  exit!
+end
+
+require_relative '../lsp'
+require_relative '../lsp/runtime'
+
+module RuboCop
+  module MCP
+    # RuboCop MCP Server.
+    # @api private
+    class Server
+      def initialize(config_store)
+        @config_store = config_store
+        @runtime = RuboCop::LSP::Runtime.new(@config_store)
+        @options = {}
+      end
+
+      def start
+        # No `protocol_version` is specified because draft feature by default can be used.
+        server = ::MCP::Server.new(
+          name: 'rubocop_mcp_server',
+          version: RuboCop::Version::STRING,
+          tools: [inspection_tool, autocorrection_tool]
+        )
+
+        ::MCP::Server::Transports::StdioTransport.new(server).open
+      end
+
+      private
+
+      def inspection_tool
+        build_tool(
+          name: 'rubocop_inspection',
+          description: 'Inspect Ruby code for offenses. ' \
+                       'Provide `source_code` to check inline code or `path` to check files.',
+          title: "RuboCop's inspection",
+          destructive_hint: false,
+          idempotent_hint: true,
+          read_only_hint: true,
+          safety_required: false
+        ) do |path, source_code|
+          run_inspection(path, source_code)
+        end
+      end
+
+      def autocorrection_tool
+        build_tool(
+          name: 'rubocop_autocorrection',
+          description: 'Autocorrect RuboCop offenses in Ruby code. ' \
+                       'Provide `source_code` to correct inline code or `path` to correct files. ' \
+                       'Set `safety` to false to include unsafe corrections.',
+          title: "RuboCop's autocorrection",
+          destructive_hint: true,
+          idempotent_hint: false,
+          read_only_hint: false,
+          safety_required: true
+        ) do |path, source_code, safety|
+          run_autocorrection(path, source_code, safety)
+        end
+      end
+
+      def run_inspection(path, source_code)
+        if source_code
+          offenses = @runtime.offenses(path || 'example.rb', source_code, source_code.encoding)
+          offenses.to_json
+        else
+          process_files(path, filter_empty: true) do |file, source|
+            offenses = @runtime.offenses(file, source, source.encoding)
+
+            { path: PathUtil.relative_path(file), offenses: offenses }
+          end
+        end
+      end
+
+      def run_autocorrection(path, source_code, safety)
+        command = safety ? 'rubocop.formatAutocorrects' : 'rubocop.formatAutocorrectsAll'
+
+        if source_code
+          @runtime.format(path || 'example.rb', source_code, command: command).tap do |corrected|
+            write_file(path, corrected) if path
+          end
+        else
+          process_files(path) do |file, source|
+            @runtime.format(file, source, command: command).then do |corrected|
+              write_file(file, corrected)
+
+              { path: PathUtil.relative_path(file), corrected: source != corrected }
+            end
+          end
+        end
+      end
+
+      def process_files(path, filter_empty: false)
+        target_finder = RuboCop::TargetFinder.new(@config_store, @options)
+        target_files = target_finder.find(path ? [path] : [], :only_recognized_file_types)
+        all_files = target_files.map { |file| yield(file, read_file(file)) }
+        files = filter_empty ? all_files.reject { |f| f[:offenses]&.empty? } : all_files
+
+        { files: files, summary: build_summary(target_files, all_files) }.to_json
+      end
+
+      def read_file(file)
+        config = @config_store.for_file(file)
+        RuboCop::ProcessedSource.from_file(
+          file, config.target_ruby_version, parser_engine: config.parser_engine
+        ).raw_source
+      rescue Errno::ENOENT
+        raise RuboCop::Error, "No such file or directory: #{file}"
+      end
+
+      def write_file(file, content)
+        File.write(file, content)
+      rescue Errno::EACCES
+        raise RuboCop::Error, "Permission denied: #{file}"
+      rescue Errno::ENOSPC
+        raise RuboCop::Error, "No space left on device: #{file}"
+      rescue Errno::EROFS
+        raise RuboCop::Error, "Read-only file system: #{file}"
+      end
+
+      # NOTE: It is useful for RuboCop's result summary to be shown in the LLM's responses
+      # during interactions, so the summary is returned in a form that is easy for the LLM
+      # to reason about. Since LLM execution is non-deterministic, it is also sensible to
+      # compute the summary deterministically at this stage.
+      def build_summary(target_files, files)
+        summary = { target_file_count: target_files.count }
+        if files.first&.key?(:offenses)
+          summary[:offense_count] = files.sum { |f| f[:offenses].size }
+        else
+          summary[:corrected_file_count] = files.count { |f| f[:corrected] }
+        end
+        summary
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      def build_tool(
+        name:, description:,
+        title:, destructive_hint:, idempotent_hint:, read_only_hint:, safety_required:
+      )
+        if safety_required
+          safety_property = { safety: { type: 'boolean' } }
+          required = ['safety']
+        else
+          safety_property = {}
+          required = nil
+        end
+
+        ::MCP::Tool.define(
+          name: name,
+          description: description,
+          input_schema: {
+            properties: {
+              path: { type: 'string' },
+              source_code: { type: 'string' }
+            }.merge(safety_property),
+            required: required
+          }.compact,
+          annotations: {
+            title: title,
+            destructive_hint: destructive_hint,
+            idempotent_hint: idempotent_hint,
+            open_world_hint: false,
+            read_only_hint: read_only_hint
+          }
+        ) do |path: nil, source_code: nil, safety: true|
+          result = yield(path, source_code, safety)
+
+          ::MCP::Tool::Response.new([{ type: 'text', text: result }])
+        rescue RuboCop::Error => e
+          ::MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/ParameterLists
+    end
+  end
+end