rubocop 1.67.0 → 1.81.7

data/lib/rubocop/lsp/routes.rb

@@ -15,7 +15,12 @@ module RuboCop
   module LSP
     # Routes for Language Server Protocol of RuboCop.
     # @api private
-    class Routes
+    class Routes # rubocop:disable Metrics/ClassLength
+      CONFIGURATION_FILE_PATTERNS = [
+        RuboCop::ConfigFinder::DOTFILE,
+        RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+      ].freeze
+
       def self.handle(name, &block)
         define_method(:"handle_#{name}", &block)
       end
@@ -37,6 +42,7 @@ module RuboCop
 
       handle 'initialize' do |request|
         initialization_options = extract_initialization_options_from(request)
+        @position_encoding = initialization_options[:position_encoding]
 
         @server.configure(initialization_options)
 
@@ -46,9 +52,10 @@ 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
-              )
+              ),
+              position_encoding: @position_encoding
             )
           )
         )
@@ -71,7 +78,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
 
@@ -96,7 +108,7 @@ module RuboCop
 
       handle 'workspace/didChangeWatchedFiles' do |request|
         changed = request[:params][:changes].any? do |change|
-          change[:uri].end_with?(RuboCop::ConfigFinder::DOTFILE)
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
         end
 
         if changed
@@ -174,14 +186,26 @@ module RuboCop
 
       def extract_initialization_options_from(request)
         safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+        position_encodings = request.dig(:params, :capabilities, :general, :positionEncodings)
 
         {
           safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
           lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
-          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true,
+          position_encoding: position_encoding(position_encodings)
         }
       end
 
+      def position_encoding(position_encodings)
+        if position_encodings&.include?('utf-8')
+          'utf-8'
+        elsif position_encodings&.include?('utf-32')
+          'utf-32'
+        else
+          'utf-16'
+        end
+      end
+
       def format_file(file_uri, command: nil)
         unless (text = @text_cache[file_uri])
           Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
@@ -189,7 +213,7 @@ module RuboCop
           return []
         end
 
-        new_text = @server.format(remove_file_protocol_from(file_uri), text, command: command)
+        new_text = @server.format(convert_file_uri_to_path(file_uri), text, command: command)
 
         return [] if new_text == text
 
@@ -204,39 +228,55 @@ module RuboCop
 
       def diagnostic(file_uri, text)
         @text_cache[file_uri] = text
-        offenses = @server.offenses(remove_file_protocol_from(file_uri), text)
-        diagnostics = offenses.map { |offense| to_diagnostic(offense) }
 
         {
           method: 'textDocument/publishDiagnostics',
           params: {
             uri: file_uri,
-            diagnostics: diagnostics
+            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri),
+                                          text, @position_encoding)
           }
         }
       end
 
-      def remove_file_protocol_from(uri)
-        uri.delete_prefix('file://')
+      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])
+        orig_text[start_pos...end_pos] = text
+        orig_text
       end
 
-      def to_diagnostic(offense)
-        code = offense[:cop_name]
-        message = offense[:message]
-        loc = offense[:location]
-        rubocop_severity = offense[:severity]
-        severity = Severity.find_by(rubocop_severity)
+      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 += line_pos(l, char)
+            return pos
+          end
+          pos += l.size
+        end
+        pos
+      end
 
-        {
-          code: code, message: message, range: to_range(loc), severity: severity, source: 'rubocop'
-        }
+      def line_pos(line, char)
+        case @position_encoding
+        when 'utf-8'
+          line.byteslice(0, char).size
+        when 'utf-32'
+          char
+        else # 'utf-16'
+          # utf-16 is default position encoding on LSP
+          # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/
+          line.encode('utf-16be').byteslice(0, char * 2).size
+        end
       end
 
-      def to_range(location)
-        {
-          start: { character: location[:start_column] - 1, line: location[:start_line] - 1 },
-          end: { character: location[:last_column], line: location[:last_line] - 1 }
-        }
+      def convert_file_uri_to_path(uri)
+        URI.decode_www_form_component(uri.delete_prefix('file://'))
       end
     end
   end

data/lib/rubocop/lsp/runtime.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'stringio'
+require_relative 'diagnostic'
+require_relative 'stdin_runner'
 
 #
 # This code is based on https://github.com/standardrb/standard.
@@ -19,59 +20,40 @@ module RuboCop
       attr_writer :safe_autocorrect, :lint_mode, :layout_mode
 
       def initialize(config_store)
-        @config_store = config_store
-        @logged_paths = []
+        RuboCop::LSP.enable
+
+        @runner = RuboCop::Lsp::StdinRunner.new(config_store)
+        @cop_registry = RuboCop::Cop::Registry.global.to_h
+
         @safe_autocorrect = true
         @lint_mode = false
         @layout_mode = false
       end
 
-      # This abuses the `--stdin` option of rubocop and reads the formatted text
-      # from the `options[:stdin]` that rubocop mutates. This depends on
-      # `parallel: false` as well as the fact that RuboCop doesn't otherwise dup
-      # or reassign that options object. Risky business!
-      #
-      # Reassigning `options[:stdin]` is done here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/team.rb#L131
-      # Printing `options[:stdin]`
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cli/command/execute_runner.rb#L95
-      # Setting `parallel: true` would break this here:
-      #   https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/runner.rb#L72
-      def format(path, text, command:)
+      def format(path, text, command:, prism_result: nil)
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
                            else
                              @safe_autocorrect
                            end
 
-        formatting_options = {
-          stdin: text, force_exclusion: true, autocorrect: true, safe_autocorrect: safe_autocorrect
-        }
+        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
         formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        redirect_stdout { run_rubocop(formatting_options, path) }
-
-        formatting_options[:stdin]
+        @runner.run(path, text, formatting_options, prism_result: prism_result)
+        @runner.formatted_source
       end
 
-      def offenses(path, text)
-        diagnostic_options = {
-          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
-        }
+      def offenses(path, text, position_encoding, prism_result: nil)
+        diagnostic_options = {}
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
-        json = redirect_stdout { run_rubocop(diagnostic_options, path) }
-        results = JSON.parse(json, symbolize_names: true)
-
-        if results[:files].empty?
-          unless @logged_paths.include?(path)
-            Logger.log "Ignoring file, per configuration: #{path}"
-            @logged_paths << path
-          end
-          return []
+        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        @runner.offenses.map do |offense|
+          Diagnostic.new(
+            position_encoding, offense, path, @cop_registry[offense.cop_name]&.first
+          ).to_lsp_diagnostic(@runner.config_for_working_directory)
         end
-
-        results.dig(:files, 0, :offenses)
       end
 
       private
@@ -82,20 +64,6 @@ module RuboCop
         only_options << 'Layout' if @layout_mode
         only_options
       end
-
-      def redirect_stdout(&block)
-        stdout = StringIO.new
-
-        RuboCop::Server::Helper.redirect(stdout: stdout, &block)
-
-        stdout.string
-      end
-
-      def run_rubocop(options, path)
-        runner = RuboCop::Runner.new(options, @config_store)
-
-        runner.run([path])
-      end
     end
   end
 end

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)
@@ -53,8 +51,8 @@ module RuboCop
         @runtime.format(path, text, command: command)
       end
 
-      def offenses(path, text)
-        @runtime.offenses(path, text)
+      def offenses(path, text, position_encoding)
+        @runtime.offenses(path, text, position_encoding)
       end
 
       def configure(options)

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/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
@@ -275,6 +279,10 @@ module RuboCop
         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

@@ -243,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')
@@ -299,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
 
@@ -397,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
@@ -415,14 +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,
-            format('Do not specify `--editor-mode` as it is redundant in `--lsp`.')
+      raise OptionArgumentError, 'Do not specify `--editor-mode` as it is redundant in `--lsp`.'
     end
 
     def validate_autocorrect
@@ -436,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
@@ -504,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',
@@ -542,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.'],
@@ -579,7 +594,8 @@ module RuboCop
                                          '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',

data/lib/rubocop/path_util.rb

@@ -28,20 +28,27 @@ 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, Metrics/PerceivedComplexity

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