rubocop 1.71.1 → 1.92.0

data/lib/rubocop/cli/command/lsp.rb

@@ -9,7 +9,7 @@ module RuboCop
         self.command_name = :lsp
 
         def run
-          # Load on demand, `languge-server-protocol` is heavy to require.
+          # Load on demand, `language-server-protocol` is heavy to require.
           require_relative '../../lsp/server'
           RuboCop::LSP::Server.new(@config_store).start
         end

data/lib/rubocop/cli/command/mcp.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Start Model Context Protocol of RuboCop.
+      # @api private
+      class MCP < Base
+        self.command_name = :mcp
+
+        def run
+          require_relative '../../mcp/server'
+
+          RuboCop::MCP::Server.new(@config_store).start
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/command/show_cops.rb

@@ -7,6 +7,8 @@ module RuboCop
       # for the current directory.
       # @api private
       class ShowCops < Base
+        include CopNames
+
         self.command_name = :show_cops
 
         ExactMatcher = Struct.new(:pattern) do
@@ -25,7 +27,7 @@ module RuboCop
           super
 
           # Load the configs so the require()s are done for custom cops
-          @config = @config_store.for(Dir.pwd)
+          @config = @config_store.for(PathUtil.pwd)
 
           @cop_matchers = @options[:show_cops].map do |pattern|
             if pattern.include?('*')
@@ -38,6 +40,10 @@ module RuboCop
 
         def run
           print_available_cops
+          # Checked after printing, so a typo alongside good names still shows
+          # what was asked for. Wildcards are patterns, not names, so a pattern
+          # that matches nothing is not an error.
+          validate_cop_names!(@options[:show_cops].grep_v(/\*/))
         end
 
         private
@@ -46,7 +52,7 @@ module RuboCop
           registry = Cop::Registry.global
           show_all = @cop_matchers.empty?
 
-          puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: " if show_all
+          puts "# Available cops (#{registry.length}) + config for #{PathUtil.pwd}: " if show_all
 
           registry.departments.sort!.each do |department|
             print_cops_of_department(registry, department, show_all)

data/lib/rubocop/cli/command/show_docs_url.rb

@@ -7,16 +7,21 @@ module RuboCop
       # or documentation base url by default.
       # @api private
       class ShowDocsUrl < Base
+        include CopNames
+
         self.command_name = :show_docs_url
 
         def initialize(env)
           super
 
-          @config = @config_store.for(Dir.pwd)
+          @config = @config_store.for(PathUtil.pwd)
         end
 
         def run
           print_documentation_url
+          # Checked after printing, so a typo alongside good names still gives
+          # you the urls you asked for.
+          validate_cop_names!(cops_array)
         end
 
         private
@@ -24,11 +29,8 @@ module RuboCop
         def print_documentation_url
           puts Cop::Documentation.default_base_url if cops_array.empty?
 
-          cops_array.each do |cop_name|
-            cop = registry_hash[cop_name]
-            next if cop.empty?
-
-            url = Cop::Documentation.url_for(cop.first, @config)
+          known_cop_classes(cops_array).each do |cop|
+            url = Cop::Documentation.url_for(cop, @config)
             puts url if url
           end
 
@@ -38,10 +40,6 @@ module RuboCop
         def cops_array
           @cops_array ||= @options[:show_docs_url]
         end
-
-        def registry_hash
-          @registry_hash ||= Cop::Registry.global.to_h
-        end
       end
     end
   end

data/lib/rubocop/cli/command/suggest_extensions.rb

@@ -60,7 +60,7 @@ module RuboCop
         def print_opt_out_instruction
           puts
           puts 'You can opt out of this message by adding the following to your config ' \
-               '(see https://docs.rubocop.org/rubocop/extensions.html#extension-suggestions ' \
+               '(see https://docs.rubocop.org/rubocop/plugins.html#plugin-suggestions ' \
                'for more options):'
           puts '  AllCops:'
           puts '    SuggestExtensions: false'
@@ -97,7 +97,13 @@ module RuboCop
         end
 
         def loaded_extensions
-          @config_store.for_pwd.loaded_features.to_a
+          rubocop_config = @config_store.for_pwd
+
+          plugin_names = rubocop_config.loaded_plugins.map do |plugin|
+            plugin.about.name
+          end
+
+          plugin_names + rubocop_config.loaded_features.to_a
         end
 
         def installed_and_not_loaded_extensions

data/lib/rubocop/cli.rb

@@ -12,8 +12,9 @@ module RuboCop
     STATUS_INTERRUPTED = Signal.list['INT'] + 128
     DEFAULT_PARALLEL_OPTIONS = %i[
       color config debug display_style_guide display_time display_only_fail_level_offenses
-      display_only_failed editor_mode except extra_details fail_level fix_layout format
-      ignore_disable_comments lint only only_guide_cops require safe
+      display_only_failed editor_mode except extra_details fail_level fix_layout format formatters
+      ignore_disable_comments lint max_offenses_per_cop only only_guide_cops out preview require
+      safe
       autocorrect safe_autocorrect autocorrect_all
     ].freeze
 
@@ -35,8 +36,10 @@ module RuboCop
     # @param args [Array<String>] command line arguments
     # @return [Integer] UNIX exit code
     #
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def run(args = ARGV)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
       @options, paths = Options.new.parse(args)
       @env = Environment.new(@options, @config_store, paths)
 
@@ -48,11 +51,12 @@ module RuboCop
           validate_options_vs_config
           parallel_by_default!
           apply_default_formatter
+          report_pending_cops
           execute_runners
         end
       end
     rescue ConfigNotFoundError, IncorrectCopNameError, OptionArgumentError => e
-      warn e.message
+      warn Rainbow(e.message).red
       STATUS_ERROR
     rescue RuboCop::Error => e
       warn Rainbow("Error: #{e.message}").red
@@ -63,7 +67,7 @@ module RuboCop
       STATUS_INTERRUPTED
     rescue Finished
       STATUS_SUCCESS
-    rescue OptionParser::InvalidOption => e
+    rescue OptionParser::ParseError => e
       warn e.message
       warn 'For usage information, use --help'
       STATUS_ERROR
@@ -71,12 +75,16 @@ module RuboCop
       warn e.message
       warn e.backtrace
       STATUS_ERROR
+    ensure
+      elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+      if @options[:debug] || @options[:display_time]
+        puts "Finished in #{elapsed_time.round(5)} seconds"
+      end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     private
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
     def profile_if_needed
       return yield unless @options[:profile]
 
@@ -108,7 +116,6 @@ module RuboCop
       end
       status
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def require_gem(name)
       require name
@@ -155,10 +162,14 @@ module RuboCop
 
     def act_on_options
       set_options_to_config_loader
+      set_options_to_pending_cops_reporter
       handle_editor_mode
 
-      @config_store.options_config = @options[:config] if @options[:config]
-      @config_store.force_default_config! if @options[:force_default_config]
+      @config_store.apply_options!(@options)
+      # Set cache root after apply_options! to ensure force_default_config is applied first.
+      early_cache_root = ConfigLoader.cache_root(@options[:cache_root])
+      ConfigLoader.cache_root = ResultCache.cache_root(@config_store, @options[:cache_root])
+      warn_if_cache_root_changed(early_cache_root, ConfigLoader.cache_root)
 
       handle_exiting_options
 
@@ -173,27 +184,38 @@ module RuboCop
 
     def set_options_to_config_loader
       ConfigLoader.debug = @options[:debug]
-      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
-      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
       ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
       ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
+      set_cop_selection_options_to_config_loader
+    end
+
+    # Options that decide which cops run, as opposed to how configuration is loaded.
+    def set_cop_selection_options_to_config_loader
+      ConfigLoader.disable_pending_cops = @options[:disable_pending_cops]
+      ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
+      ConfigLoader.enabled_by_default = @options[:enable_all_cops]
+      ConfigLoader.disabled_by_default = @options[:disable_all_cops]
+      ConfigLoader.preview = @options[:preview]
+    end
+
+    def set_options_to_pending_cops_reporter
+      PendingCopsReporter.disable_pending_cops = @options[:disable_pending_cops]
+      PendingCopsReporter.enable_pending_cops = @options[:enable_pending_cops]
     end
 
     def handle_editor_mode
       RuboCop::LSP.enable if @options[:editor_mode]
     end
 
-    # rubocop:disable Metrics/CyclomaticComplexity
     def handle_exiting_options
       return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
 
       run_command(:version) if @options[:version] || @options[:verbose_version]
-      run_command(:show_cops) if @options[:show_cops]
-      run_command(:show_docs_url) if @options[:show_docs_url]
-      run_command(:lsp) if @options[:lsp]
+      %i[show_cops list_enabled_cops_for show_docs_url explain lsp mcp].each do |name|
+        run_command(name) if @options[name]
+      end
       raise Finished
     end
-    # rubocop:enable Metrics/CyclomaticComplexity
 
     def apply_default_formatter
       # This must be done after the options have already been processed,
@@ -208,5 +230,25 @@ module RuboCop
         [[formatter, @options[:output_path]]]
       end
     end
+
+    def report_pending_cops
+      PendingCopsReporter.warn_if_needed(@config_store.for_pwd)
+    end
+
+    def warn_if_cache_root_changed(early, desired)
+      return if early == desired
+      # Normalize paths to avoid false positives from symlink resolution differences
+      if File.exist?(early) && File.exist?(desired) &&
+         File.realpath(early) == File.realpath(desired)
+        return
+      end
+
+      warn Rainbow(
+        "Warning: Remote configuration cache files were stored in `#{early}` " \
+        "because a desired cache root (`#{desired}`) was not set at the top level. " \
+        'Consider setting `AllCops: CacheRootDirectory` in your toplevel configuration file, ' \
+        'using the `RUBOCOP_CACHE_ROOT` environment variable, or using CLI options.'
+      ).yellow
+    end
   end
 end

data/lib/rubocop/comment_config/directive_range.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # A disabled line range that remembers the directive comment that opened
+    # it. Value-equal to a plain `Range`, so consumers comparing or hashing
+    # ranges are unaffected.
+    # @api private
+    class DirectiveRange < Range
+      attr_reader :directive
+
+      def initialize(first_line, last_line, directive)
+        super(first_line, last_line)
+        @directive = directive
+      end
+    end
+
+    # The per-cop state accumulated while analyzing directives: the disabled
+    # ranges so far, plus the line and directive of the currently open
+    # disable, if any.
+    # @api private
+    CopAnalysis = Struct.new(:line_ranges, :start_line_number, :start_directive) do
+      # The open range (if any) closed at the given line, appended to the
+      # accumulated ranges, each remembering the directive that opened it.
+      # Closing above the opening line (e.g. a `pop` directly below a
+      # statement whose disable a `next +Cop` suspended) yields no range.
+      def close(line)
+        return line_ranges if !start_line_number || line < start_line_number
+
+        line_ranges + [DirectiveRange.new(start_line_number, line, start_directive)]
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config/disable_next.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # Handling of next-statement directives (`disable-next`, `todo-next` and
+    # `next`): computing the statement scope they apply to and tracking
+    # directives that attached to nothing.
+    # The scope is the whole statement starting on the next line bearing
+    # code. Comment-only lines between the directive and the code chain (so
+    # several directives can stack), while a blank line breaks the attachment.
+    # @api private
+    module DisableNext
+      # Next-statement directives that affect nothing: nothing follows
+      # them, or they sit at the end of a code line.
+      def detached_next_directives
+        cop_disabled_line_ranges # ensure the analysis that collects them ran
+        @detached_next_directives
+      end
+
+      # The line range of the statement a `disable-next` directive on the
+      # given line scopes to (or would scope to), or `nil` when no statement
+      # is attached. A directive is only honored on a comment-only line.
+      # Stacked directives share the target, so the computation is memoized.
+      # @api private
+      def statement_scope_after(line)
+        return nil unless comment_only_line?(line)
+
+        code_line = attached_code_line(line)
+        return nil unless code_line
+
+        (@statement_bounds ||= {})[code_line] ||= statement_bounds_at(code_line)
+      end
+
+      private
+
+      def apply_disable_next(analyses, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        range = DirectiveRange.new(bounds.begin, bounds.end, directive)
+        directive.cop_names.each do |cop_name|
+          add_next_range(analyses, qualified_cop_name(cop_name), range)
+        end
+      end
+
+      def add_next_range(analyses, cop_name, range)
+        analysis = analyses[cop_name]
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [range],
+                                             analysis.start_line_number, analysis.start_directive)
+      end
+
+      # Applies a `next` directive: `-` cops are disabled for the attached
+      # statement (exactly like `disable-next`), `+` cops have any open
+      # disable suspended for it. The `resolved_cops` come pre-expanded and
+      # qualified, mirroring `push`.
+      def apply_next_directive(analyses, resolved_cops, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        range = DirectiveRange.new(bounds.begin, bounds.end, directive)
+        resolved_cops.each do |op, cops|
+          cops.each do |cop|
+            if op == '-'
+              add_next_range(analyses, cop, range)
+            else
+              suspend_disable(analyses, cop, bounds)
+            end
+          end
+        end
+      end
+
+      # Applies an `enable-next` directive: every listed cop (departments
+      # and `all` included) has any open disable suspended for the attached
+      # statement.
+      def apply_enable_next(analyses, directive)
+        bounds = statement_scope_after(directive.line_number)
+        return @detached_next_directives << directive unless bounds
+
+        directive.cop_names.each do |cop_name|
+          suspend_disable(analyses, qualified_cop_name(cop_name), bounds)
+        end
+      end
+
+      # Punches a statement-sized hole into the currently open disable of the
+      # cop (whether opened by a directive or injected for a config-disabled
+      # cop): the open range closes just above the statement and reopens
+      # right below it, still attributed to its opening directive. Aligned
+      # with `push`, a `+` for a cop that is not disabled is a no-op.
+      def suspend_disable(analyses, cop, bounds)
+        analysis = analyses[cop]
+        return unless analysis.start_line_number
+
+        analyses[cop] = CopAnalysis.new(analysis.close(bounds.begin - 1),
+                                        bounds.end + 1, analysis.start_directive)
+      end
+
+      def attached_code_line(directive_line)
+        ((directive_line + 1)..processed_source.lines.size).each do |line|
+          return line unless comment_only_line?(line)
+          return nil if processed_source[line - 1].blank?
+        end
+
+        nil
+      end
+
+      def statement_bounds_at(line)
+        statement = statement_starting_at(line)
+        # A code line where no statement starts (e.g. a lone `end`) scopes
+        # the directive to that line alone.
+        return (line..line) unless statement
+
+        (line..statement_end_line(statement))
+      end
+
+      def statement_start_line?(node, line)
+        # Synthetic nodes (e.g. parentheses-less argument lists) have no
+        # source range. `begin` nodes are sequences of statements, not
+        # statements themselves - taking one would scope the directive to
+        # everything up to the last statement of the sequence.
+        node.source_range && node.first_line == line && !node.begin_type?
+      end
+
+      def statement_starting_at(line)
+        ast = processed_source.ast
+        return nil unless ast
+
+        ast.each_node.select { |node| statement_start_line?(node, line) }.max_by(&:last_line)
+      end
+
+      def statement_end_line(statement)
+        statement.each_node.filter_map do |node|
+          next unless node.source_range
+
+          heredoc?(node) ? node.loc.heredoc_end.line : node.last_line
+        end.max
+      end
+
+      def heredoc?(node)
+        node.respond_to?(:heredoc?) && node.heredoc?
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config/push_pop.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CommentConfig
+    # Handling of `push`/`pop` directives and their signed cop arguments:
+    # saving and restoring the per-cop analysis state, and resolving the
+    # `+`/`-` argument lists (shared with the `next` directive).
+    # @api private
+    module PushPop
+      private
+
+      def resolve_push_cops(directive)
+        directive.push_args.transform_values do |names|
+          names.flat_map { |name| expand_cop_name(name) }
+        end
+      end
+
+      def expand_cop_name(name)
+        registry = Cop::Registry.global
+        cops = registry.department?(name) ? registry.names_for_department(name) : [name]
+        cops.map { |c| qualified_cop_name(c) }
+      end
+
+      def apply_push(analyses, resolved_cops, directive)
+        resolved_cops.each do |op, cops|
+          cops.each { |cop| apply_cop_op(analyses, op, cop, directive) }
+        end
+      end
+
+      def apply_cop_op(analyses, operation, cop, directive)
+        analysis = analyses[cop]
+        line = directive.line_number
+        if operation == '-' && !analysis.start_line_number
+          analyses[cop] = CopAnalysis.new(analysis.line_ranges, line, directive)
+        elsif operation == '+' && analysis.start_line_number
+          analyses[cop] = CopAnalysis.new(analysis.close(line), nil)
+        end
+      end
+
+      def pop_state(analyses, line)
+        restore_point = @stack.pop
+        (restore_point.keys | analyses.keys).each do |cop|
+          analyses[cop] = popped_analysis(analyses[cop], restore_point[cop], line)
+        end
+      end
+
+      def popped_analysis(current, restored, line)
+        ranges = current.close(line - 1)
+        return CopAnalysis.new(ranges, nil) unless restored&.start_line_number
+
+        CopAnalysis.new(ranges, line, restored.start_directive)
+      end
+    end
+  end
+end