rubocop 1.84.2 → 1.88.0

data/lib/rubocop/cop/team.rb

@@ -11,6 +11,9 @@ module RuboCop
     # (unless autocorrections happened).
     # rubocop:disable Metrics/ClassLength
     class Team
+      InvestigationResult = Struct.new(:report, :corrector)
+      private_constant :InvestigationResult
+
       # @return [Team]
       def self.new(cop_or_classes, config, options = {})
         # Support v0 api:
@@ -89,31 +92,25 @@ module RuboCop
 
       # @return [Commissioner::InvestigationReport]
       def investigate(processed_source, offset: 0, original: processed_source)
-        be_ready
-
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run autocorrecting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source)
+        result = investigate_with_corrector(processed_source, offset: offset, original: original)
+        autocorrect(processed_source, result.corrector)
+        result.report
+      end
 
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-        report = investigate_partial(autocorrect_cops, processed_source,
-                                     offset: offset, original: original)
+      # @return [Array<Offense>]
+      def investigate_fragments(fragments, original:)
+        @updated_source_file = false
 
-        unless autocorrect(processed_source, report, offset: offset, original: original)
-          # If we corrected some errors, another round of inspection will be
-          # done, and any other offenses will be caught then, so only need
-          # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source,
-                                                    offset: offset, original: original))
-        end
+        offenses, errors, warnings, corrector =
+          fragments.each_with_object([[], [], [], nil]) do |fragment, data|
+            investigate_fragment(fragment, original, data)
+          end
 
-        process_errors(processed_source.path, report.errors)
+        autocorrect(original, corrector)
+        @errors = errors
+        @warnings = warnings
 
-        report
-      ensure
-        @ready = false
+        offenses
       end
 
       # @deprecated
@@ -136,14 +133,13 @@ module RuboCop
 
       private
 
-      def autocorrect(processed_source, report, original:, offset:)
+      def autocorrect(processed_source, corrector)
         @updated_source_file = false
         return unless autocorrect?
-        return if report.processed_source.parser_error
+        return unless corrector
+        return if corrector.empty?
 
-        new_source = autocorrect_report(report, original: original, offset: offset)
-
-        return unless new_source
+        new_source = corrector.rewrite
 
         if @options[:stdin]
           # holds source read in from stdin, when --stdin option is used
@@ -174,6 +170,54 @@ module RuboCop
         commissioner.investigate(processed_source, offset: offset, original: original)
       end
 
+      def investigate_with_corrector(processed_source, offset:, original:)
+        be_ready
+
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run autocorrecting cops by themselves, and only
+        # run the other cops when no corrections are left
+        on_duty = roundup_relevant_cops(processed_source)
+
+        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
+
+        corrector = collated_corrector(report, offset: offset, original: original)
+
+        unless corrector
+          # If we corrected some errors, another round of inspection will be
+          # done, and any other offenses will be caught then, so only need
+          # to check other_cops if no correction was done
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
+        end
+
+        process_errors(processed_source.path, report.errors)
+
+        InvestigationResult.new(report, corrector)
+      ensure
+        @ready = false
+      end
+
+      def investigate_fragment(fragment, original, data)
+        offenses, errors, warnings, corrector = data
+        result = investigate_with_corrector(
+          fragment[:processed_source],
+          offset: fragment[:offset],
+          original: original
+        )
+
+        offenses.concat(result.report.offenses)
+        if result.corrector
+          corrector ||= Corrector.new(original)
+          merge_corrector!(corrector, result.corrector, offset: 0)
+          data[3] = corrector
+        end
+        errors.concat(@errors)
+        warnings.concat(@warnings)
+      end
+
       # @return [Array<cop>]
       def roundup_relevant_cops(processed_source)
         cops.select do |cop|
@@ -200,28 +244,35 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_report(report, offset:, original:)
+      def collated_corrector(report, offset:, original:)
+        return unless autocorrect?
+        return if report.processed_source.parser_error
+
         corrector = collate_corrections(report, offset: offset, original: original)
 
-        corrector.rewrite unless corrector.empty?
+        corrector unless corrector.empty?
       end
 
       def collate_corrections(report, offset:, original:)
         corrector = Corrector.new(original)
 
         each_corrector(report) do |to_merge|
-          suppress_clobbering do
-            if corrector.source_buffer == to_merge.source_buffer
-              corrector.merge!(to_merge)
-            else
-              corrector.import!(to_merge, offset: offset)
-            end
-          end
+          merge_corrector!(corrector, to_merge, offset: offset)
         end
 
         corrector
       end
 
+      def merge_corrector!(corrector, to_merge, offset:)
+        suppress_clobbering do
+          if corrector.source_buffer == to_merge.source_buffer
+            corrector.merge!(to_merge)
+          else
+            corrector.import!(to_merge, offset: offset)
+          end
+        end
+      end
+
       def each_corrector(report)
         skips = Set.new
         report.cop_reports.each do |cop_report|

data/lib/rubocop/cop/variable_force/branch.rb

@@ -346,8 +346,8 @@ module RuboCop
           end
         end
 
-        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
-          classes[klass.type] = klass
+        CLASSES_BY_TYPE = Base.classes.to_h do |klass|
+          [klass.type, klass]
         end
       end
     end

data/lib/rubocop/directive_comment.rb

@@ -52,7 +52,8 @@ module RuboCop
     def initialize(comment, cop_registry = Cop::Registry.global)
       @comment = comment
       @cop_registry = cop_registry
-      @match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      match_data = comment.text.match(DIRECTIVE_COMMENT_REGEXP)
+      @match_data = match_data&.pre_match&.match?(/\A#\s*\z/) ? nil : match_data
       @mode, @cops = match_captures
     end
 

data/lib/rubocop/file_patterns.rb

@@ -21,11 +21,19 @@ module RuboCop
     def initialize(patterns)
       @strings = Set.new
       @patterns = []
+      @match_cache = {}
       partition_patterns(patterns)
     end
 
     def match?(path)
-      @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
+      # `FilePatterns.from` memoizes one instance per pattern array (by identity),
+      # so this cache is shared across every cop using the same Include/Exclude
+      # list. Patterns are immutable within a run, so caching by path is safe.
+      cached = @match_cache[path]
+      return cached unless cached.nil?
+
+      @match_cache[path] =
+        @strings.include?(path) || @patterns.any? { |pattern| PathUtil.match_path?(pattern, path) }
     end
 
     private

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -91,12 +91,9 @@ module RuboCop
         command = 'rubocop --auto-gen-config'
 
         command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
-
-        if no_exclude_limit?
-          command += ' --no-exclude-limit'
-        elsif @exclude_limit_option
-          command += format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
-        end
+        command += ' --disable-pending-cops' if @options[:disable_pending_cops]
+        command += ' --enable-pending-cops' if @options[:enable_pending_cops]
+        command += exclude_limit_option
         command += ' --no-offense-counts' unless show_offense_counts?
 
         command += ' --no-auto-gen-timestamp' unless show_timestamp?
@@ -106,6 +103,16 @@ module RuboCop
         command
       end
 
+      def exclude_limit_option
+        if no_exclude_limit?
+          ' --no-exclude-limit'
+        elsif @exclude_limit_option
+          format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
+        else
+          ''
+        end
+      end
+
       def timestamp
         show_timestamp? ? "on #{Time.now.utc} " : ''
       end
@@ -131,6 +138,9 @@ module RuboCop
       end
 
       def set_max(cfg, cop_name)
+        exclude_limits = RuboCop::ExcludeLimit.read_limits(cop_name)
+        cfg[:exclude_limit] = exclude_limits unless exclude_limits.empty?
+
         return unless cfg[:exclude_limit]
 
         cfg.merge!(cfg[:exclude_limit]) if should_set_max?(cop_name)
@@ -155,7 +165,7 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
         cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
-        default_cfg = default_config(cop_name)
+        default_cfg = default_config(cop_name) || @config_for_pwd[cop_name]
 
         if supports_safe_autocorrect?(cop_class, default_cfg)
           output_buffer.puts '# This cop supports safe autocorrection (--autocorrect).'
@@ -192,7 +202,7 @@ module RuboCop
           next unless value.is_a?(Array)
           next if value.empty?
 
-          value.map! { |v| v.nil? ? '~' : v } # Change nil back to ~ as in the YAML file.
+          value = value.map { |v| v.nil? ? '~' : v } # Change nil back to ~ as in the YAML file.
           output_buffer.puts "# #{param}: #{value.uniq.join(', ')}"
         end
       end
@@ -233,7 +243,7 @@ module RuboCop
 
       def output_exclude_list(output_buffer, offending_files, cop_name)
         require 'pathname'
-        parent = Pathname.new(Dir.pwd)
+        parent = Pathname.new(PathUtil.pwd)
 
         output_buffer.puts '  Exclude:'
         excludes(offending_files, cop_name, parent).each do |exclude_path|

data/lib/rubocop/formatter/formatter_set.rb

@@ -57,7 +57,7 @@ module RuboCop
         if output_path
           dir_path = File.dirname(output_path)
           FileUtils.mkdir_p(dir_path)
-          output = File.open(output_path, 'w')
+          output = File.open(output_path, 'w') # rubocop:disable Style/FileOpen
         else
           output = $stdout
         end

data/lib/rubocop/formatter/junit_formatter.rb

@@ -93,7 +93,7 @@ module RuboCop
 
       def classname_attribute_value(file)
         @classname_attribute_value_cache ||= Hash.new do |hash, key|
-          hash[key] = key.delete_suffix('.rb').gsub("#{Dir.pwd}/", '').tr('/', '.')
+          hash[key] = key.delete_suffix('.rb').gsub("#{PathUtil.pwd}/", '').tr('/', '.')
         end
         @classname_attribute_value_cache[file]
       end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'colorizable'
-
 module RuboCop
   module Formatter
     # A basic formatter that displays only files with offenses.

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -24,7 +24,7 @@ module RuboCop
       def file_finished(file, offenses)
         return if offenses.empty?
 
-        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        path = Pathname.new(file).relative_path_from(Pathname.new(PathUtil.pwd))
         @offense_counts[path] = offenses.size
       end
 

data/lib/rubocop/formatter.rb

@@ -3,32 +3,33 @@
 module RuboCop
   # The bootstrap module for formatter.
   module Formatter
-    require_relative 'formatter/text_util'
+    autoload :Colorizable, 'rubocop/formatter/colorizable'
+    autoload :TextUtil, 'rubocop/formatter/text_util'
 
-    require_relative 'formatter/base_formatter'
-    require_relative 'formatter/simple_text_formatter'
+    autoload :BaseFormatter, 'rubocop/formatter/base_formatter'
+    autoload :SimpleTextFormatter, 'rubocop/formatter/simple_text_formatter'
 
     # relies on simple text
-    require_relative 'formatter/clang_style_formatter'
-    require_relative 'formatter/disabled_config_formatter'
-    require_relative 'formatter/emacs_style_formatter'
-    require_relative 'formatter/file_list_formatter'
-    require_relative 'formatter/fuubar_style_formatter'
-    require_relative 'formatter/github_actions_formatter'
-    require_relative 'formatter/html_formatter'
-    require_relative 'formatter/json_formatter'
-    require_relative 'formatter/junit_formatter'
-    require_relative 'formatter/markdown_formatter'
-    require_relative 'formatter/offense_count_formatter'
-    require_relative 'formatter/pacman_formatter'
-    require_relative 'formatter/progress_formatter'
-    require_relative 'formatter/quiet_formatter'
-    require_relative 'formatter/tap_formatter'
-    require_relative 'formatter/worst_offenders_formatter'
+    autoload :ClangStyleFormatter, 'rubocop/formatter/clang_style_formatter'
+    autoload :DisabledConfigFormatter, 'rubocop/formatter/disabled_config_formatter'
+    autoload :EmacsStyleFormatter, 'rubocop/formatter/emacs_style_formatter'
+    autoload :FileListFormatter, 'rubocop/formatter/file_list_formatter'
+    autoload :FuubarStyleFormatter, 'rubocop/formatter/fuubar_style_formatter'
+    autoload :GitHubActionsFormatter, 'rubocop/formatter/github_actions_formatter'
+    autoload :HTMLFormatter, 'rubocop/formatter/html_formatter'
+    autoload :JSONFormatter, 'rubocop/formatter/json_formatter'
+    autoload :JUnitFormatter, 'rubocop/formatter/junit_formatter'
+    autoload :MarkdownFormatter, 'rubocop/formatter/markdown_formatter'
+    autoload :OffenseCountFormatter, 'rubocop/formatter/offense_count_formatter'
+    autoload :PacmanFormatter, 'rubocop/formatter/pacman_formatter'
+    autoload :ProgressFormatter, 'rubocop/formatter/progress_formatter'
+    autoload :QuietFormatter, 'rubocop/formatter/quiet_formatter'
+    autoload :TapFormatter, 'rubocop/formatter/tap_formatter'
+    autoload :WorstOffendersFormatter, 'rubocop/formatter/worst_offenders_formatter'
 
     # relies on progress formatter
-    require_relative 'formatter/auto_gen_config_formatter'
+    autoload :AutoGenConfigFormatter, 'rubocop/formatter/auto_gen_config_formatter'
 
-    require_relative 'formatter/formatter_set'
+    autoload :FormatterSet, 'rubocop/formatter/formatter_set'
   end
 end

data/lib/rubocop/lsp/diagnostic.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'language_server-protocol'
 require_relative 'disable_comment_edits'
 require_relative 'severity'
 

data/lib/rubocop/lsp/routes.rb

@@ -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|

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
@@ -63,7 +62,7 @@ module RuboCop
           document_encoding,
           offense,
           path,
-          @cop_registry[offense.cop_name]&.first,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
           processed_source
         ).to_lsp_diagnostic(config)
       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