rubocop 1.69.2 → 1.71.0

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,24 +20,14 @@ module RuboCop
       attr_writer :safe_autocorrect, :lint_mode, :layout_mode
 
       def initialize(config_store)
-        @config_store = config_store
-        @logged_paths = []
+        @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:)
         safe_autocorrect = if command
                              command == 'rubocop.formatAutocorrects'
@@ -44,34 +35,23 @@ module RuboCop
                              @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)
+        @runner.formatted_source
       end
 
-      def offenses(path, text)
-        diagnostic_options = {
-          stdin: text, force_exclusion: true, formatters: ['json'], format: 'json'
-        }
+      def offenses(path, text, document_encoding = 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)
+        @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)
         end
-
-        results.dig(:files, 0, :offenses)
       end
 
       private
@@ -82,20 +62,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/stdin_runner.rb

@@ -0,0 +1,83 @@
+# 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
+
+      # rubocop:disable Metrics/MethodLength
+      def run(path, contents, options)
+        @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
+        @options[:stdin] = contents
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        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
+
+      private
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+    end
+  end
+end

data/lib/rubocop/options.rb

@@ -579,7 +579,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

@@ -32,16 +32,19 @@ module RuboCop
     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/result_cache.rb

@@ -25,16 +25,16 @@ module RuboCop
     # cleaning should be done relatively seldom, since there is a slight risk
     # that some other RuboCop process was just about to read the file, when
     # there's parallel execution and the cache is shared.
-    def self.cleanup(config_store, verbose, cache_root = nil)
+    def self.cleanup(config_store, verbose, cache_root_override = nil)
       return if inhibit_cleanup # OPTIMIZE: For faster testing
 
-      cache_root ||= cache_root(config_store)
-      return unless File.exist?(cache_root)
+      rubocop_cache_dir = cache_root(config_store, cache_root_override)
+      return unless File.exist?(rubocop_cache_dir)
 
-      files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
+      files, dirs = Find.find(rubocop_cache_dir).partition { |path| File.file?(path) }
       return unless requires_file_removal?(files.length, config_store)
 
-      remove_oldest_files(files, dirs, cache_root, verbose)
+      remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
     end
 
     class << self
@@ -49,11 +49,11 @@ module RuboCop
         file_count > 1 && file_count > config_store.for_pwd.for_all_cops['MaxFilesInCache']
       end
 
-      def remove_oldest_files(files, dirs, cache_root, verbose)
+      def remove_oldest_files(files, dirs, rubocop_cache_dir, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
         remove_count = (files.length / 2) + 1
-        puts "Removing the #{remove_count} oldest files from #{cache_root}" if verbose
+        puts "Removing the #{remove_count} oldest files from #{rubocop_cache_dir}" if verbose
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count)
       rescue Errno::ENOENT
@@ -72,9 +72,9 @@ module RuboCop
       end
     end
 
-    def self.cache_root(config_store)
+    def self.cache_root(config_store, cache_root_override = nil)
       CacheConfig.root_dir do
-        config_store.for_pwd.for_all_cops['CacheRootDirectory']
+        cache_root_override || config_store.for_pwd.for_all_cops['CacheRootDirectory']
       end
     end
 
@@ -84,12 +84,12 @@ module RuboCop
 
     attr_reader :path
 
-    def initialize(file, team, options, config_store, cache_root = nil)
-      cache_root ||= File.join(options[:cache_root], 'rubocop_cache') if options[:cache_root]
-      cache_root ||= ResultCache.cache_root(config_store)
+    def initialize(file, team, options, config_store, cache_root_override = nil)
+      cache_root_override ||= options[:cache_root] if options[:cache_root]
+      rubocop_cache_dir = ResultCache.cache_root(config_store, cache_root_override)
       @allow_symlinks_in_cache_location =
         ResultCache.allow_symlinks_in_cache_location?(config_store)
-      @path = File.join(cache_root,
+      @path = File.join(rubocop_cache_dir,
                         rubocop_checksum,
                         context_checksum(team, options),
                         file_checksum(file, config_store))

data/lib/rubocop/rspec/expect_offense.rb

@@ -190,7 +190,10 @@ module RuboCop
       def expect_no_offenses(source, file = nil)
         offenses = inspect_source(source, file)
 
-        expected_annotations = AnnotatedSource.parse(source)
+        # Since source given `expect_no_offenses` does not have annotations, we do not need to parse
+        # for them, and can just build an `AnnotatedSource` object from the source lines.
+        # This also prevents treating source lines that begin with a caret as an annotation.
+        expected_annotations = AnnotatedSource.new(source.each_line.to_a, [])
         actual_annotations = expected_annotations.with_offense_annotations(offenses)
         expect(actual_annotations.to_s).to eq(source)
       end
@@ -221,7 +224,8 @@ module RuboCop
 
       # Parsed representation of code annotated with the `^^^ Message` style
       class AnnotatedSource
-        ANNOTATION_PATTERN = /\A\s*(\^+|\^{}) ?/.freeze
+        # Ignore escaped carets, don't treat as annotations
+        ANNOTATION_PATTERN = /\A\s*((?<!\\)\^+|\^{}) ?/.freeze
         ABBREV = "[...]\n"
 
         # @param annotated_source [String] string passed to the matchers

data/lib/rubocop/rspec/shared_contexts.rb

@@ -98,6 +98,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
   let(:cop_options) { {} }
 
+  let(:gem_versions) { {} }
+
   ### Utilities
 
   def source_range(range, buffer: source_buffer)
@@ -138,7 +140,8 @@ RSpec.shared_context 'config' do # rubocop:disable Metrics/BlockLength
 
     allow(config).to receive(:gem_versions_in_target).and_return(
       {
-        'railties' => rails_version_in_gemfile
+        'railties' => rails_version_in_gemfile,
+        **gem_versions.transform_values { |value| Gem::Version.new(value) }
       }
     )
 

data/lib/rubocop/runner.rb

@@ -20,11 +20,7 @@ module RuboCop
         message = 'Infinite loop detected'
         message += " in #{path}" if path
         message += " and caused by #{root_cause}" if root_cause
-        message += "\n"
-        hint = 'Hint: Please update to the latest RuboCop version if not already in use, ' \
-               "and report a bug if the issue still occurs on this version.\n" \
-               'Please check the latest version at https://rubygems.org/gems/rubocop.'
-        super(Rainbow(message).red + Rainbow(hint).yellow)
+        super(message)
       end
     end
 
@@ -157,8 +153,11 @@ module RuboCop
       file_started(file)
       offenses = file_offenses(file)
     rescue InfiniteCorrectionLoop => e
+      raise e if @options[:raise_cop_error]
+
+      errors << e
+      warn Rainbow(e.message).red
       offenses = e.offenses.compact.sort.freeze
-      raise
     ensure
       file_finished(file, offenses || [])
     end

data/lib/rubocop/target_finder.rb

@@ -127,6 +127,7 @@ module RuboCop
       if mode == :only_recognized_file_types || force_exclusion?
         files.select! { |file| included_file?(file) }
       end
+      files.reject! { |file| FileTest.directory?(file) }
 
       force_exclusion? ? without_excluded(files) : files
     end

data/lib/rubocop/target_ruby.rb

@@ -34,6 +34,20 @@ module RuboCop
       end
     end
 
+    # The target ruby version may be configured by setting the
+    # `RUBOCOP_TARGET_RUBY_VERSION` environment variable.
+    class RuboCopEnvVar < Source
+      def name
+        '`RUBOCOP_TARGET_RUBY_VERSION` environment variable'
+      end
+
+      private
+
+      def find_version
+        ENV.fetch('RUBOCOP_TARGET_RUBY_VERSION', nil)&.to_f
+      end
+    end
+
     # The target ruby version may be configured in RuboCop's config.
     # @api private
     class RuboCopConfig < Source
@@ -246,6 +260,7 @@ module RuboCop
     end
 
     SOURCES = [
+      RuboCopEnvVar,
       RuboCopConfig,
       GemspecFile,
       RubyVersionFile,

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.69.2'
+    STRING = '1.71.0'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/lib/rubocop.rb

@@ -100,6 +100,7 @@ require_relative 'rubocop/cop/mixin/frozen_string_literal'
 require_relative 'rubocop/cop/mixin/gem_declaration'
 require_relative 'rubocop/cop/mixin/gemspec_help'
 require_relative 'rubocop/cop/mixin/hash_alignment_styles'
+require_relative 'rubocop/cop/mixin/hash_subset'
 require_relative 'rubocop/cop/mixin/hash_transform_method'
 require_relative 'rubocop/cop/mixin/integer_node'
 require_relative 'rubocop/cop/mixin/interpolation'
@@ -293,6 +294,7 @@ require_relative 'rubocop/cop/lint/ambiguous_operator'
 require_relative 'rubocop/cop/lint/ambiguous_operator_precedence'
 require_relative 'rubocop/cop/lint/ambiguous_range'
 require_relative 'rubocop/cop/lint/ambiguous_regexp_literal'
+require_relative 'rubocop/cop/lint/array_literal_in_regexp'
 require_relative 'rubocop/cop/lint/assignment_in_condition'
 require_relative 'rubocop/cop/lint/big_decimal_new'
 require_relative 'rubocop/cop/lint/binary_operator_with_identical_operands'
@@ -300,6 +302,7 @@ require_relative 'rubocop/cop/lint/boolean_symbol'
 require_relative 'rubocop/cop/lint/circular_argument_reference'
 require_relative 'rubocop/cop/lint/constant_definition_in_block'
 require_relative 'rubocop/cop/lint/constant_overwritten_in_rescue'
+require_relative 'rubocop/cop/lint/constant_reassignment'
 require_relative 'rubocop/cop/lint/constant_resolution'
 require_relative 'rubocop/cop/lint/debugger'
 require_relative 'rubocop/cop/lint/deprecated_class_methods'
@@ -329,6 +332,7 @@ require_relative 'rubocop/cop/lint/empty_in_pattern'
 require_relative 'rubocop/cop/lint/empty_interpolation'
 require_relative 'rubocop/cop/lint/empty_when'
 require_relative 'rubocop/cop/lint/ensure_return'
+require_relative 'rubocop/cop/lint/shared_mutable_default'
 require_relative 'rubocop/cop/lint/erb_new_arguments'
 require_relative 'rubocop/cop/lint/flip_flop'
 require_relative 'rubocop/cop/lint/float_comparison'
@@ -557,6 +561,7 @@ require_relative 'rubocop/cop/style/hash_conversion'
 require_relative 'rubocop/cop/style/hash_each_methods'
 require_relative 'rubocop/cop/style/hash_except'
 require_relative 'rubocop/cop/style/hash_like_case'
+require_relative 'rubocop/cop/style/hash_slice'
 require_relative 'rubocop/cop/style/hash_syntax'
 require_relative 'rubocop/cop/style/hash_transform_keys'
 require_relative 'rubocop/cop/style/hash_transform_values'
@@ -573,6 +578,7 @@ require_relative 'rubocop/cop/style/inverse_methods'
 require_relative 'rubocop/cop/style/inline_comment'
 require_relative 'rubocop/cop/style/invertible_unless_condition'
 require_relative 'rubocop/cop/style/ip_addresses'
+require_relative 'rubocop/cop/style/it_assignment'
 require_relative 'rubocop/cop/style/keyword_arguments_merging'
 require_relative 'rubocop/cop/style/keyword_parameters_order'
 require_relative 'rubocop/cop/style/lambda'

data/lib/ruby_lsp/rubocop/addon.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../../rubocop'
+require_relative '../../rubocop/lsp/logger'
+require_relative 'wraps_built_in_lsp_runtime'
+
+module RubyLsp
+  module RuboCop
+    # A Ruby LSP add-on for RuboCop.
+    class Addon < RubyLsp::Addon
+      def initializer
+        @wraps_built_in_lsp_runtime = nil
+      end
+
+      def name
+        'RuboCop'
+      end
+
+      def activate(global_state, message_queue)
+        ::RuboCop::LSP::Logger.log(
+          "Activating RuboCop LSP addon #{::RuboCop::Version::STRING}.", prefix: '[RuboCop]'
+        )
+
+        ::RuboCop::LSP.enable
+        @wraps_built_in_lsp_runtime = WrapsBuiltinLspRuntime.new
+
+        global_state.register_formatter('rubocop', @wraps_built_in_lsp_runtime)
+
+        register_additional_file_watchers(global_state, message_queue)
+
+        ::RuboCop::LSP::Logger.log(
+          "Initialized RuboCop LSP addon #{::RuboCop::Version::STRING}.", prefix: '[RuboCop]'
+        )
+      end
+
+      def deactivate
+        @wraps_built_in_lsp_runtime = nil
+      end
+
+      # rubocop:disable Layout/LineLength, Metrics/MethodLength
+      def register_additional_file_watchers(global_state, message_queue)
+        return unless global_state.supports_watching_files
+
+        message_queue << Request.new(
+          id: 'rubocop-file-watcher',
+          method: 'client/registerCapability',
+          params: Interface::RegistrationParams.new(
+            registrations: [
+              Interface::Registration.new(
+                id: 'workspace/didChangeWatchedFilesRuboCop',
+                method: 'workspace/didChangeWatchedFiles',
+                register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                  watchers: [
+                    Interface::FileSystemWatcher.new(
+                      glob_pattern: '**/.rubocop{,_todo}.yml',
+                      kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      end
+      # rubocop:enable Layout/LineLength, Metrics/MethodLength
+
+      def workspace_did_change_watched_files(changes)
+        return unless changes.any? { |change| change[:uri].end_with?('.rubocop.yml') }
+
+        @wraps_built_in_lsp_runtime.init!
+
+        ::RuboCop::LSP::Logger(<<~MESSAGE, prefix: '[RuboCop]')
+          Re-initialized RuboCop LSP addon #{::RuboCop::Version::STRING} due to .rubocop.yml file change.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/ruby_lsp/rubocop/wraps_built_in_lsp_runtime.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../rubocop/lsp/runtime'
+
+module RubyLsp
+  module RuboCop
+    # Wrap RuboCop's built-in runtime for Ruby LSP's add-on.
+    class WrapsBuiltinLspRuntime
+      include RubyLsp::Requests::Support::Formatter
+
+      def initialize
+        init!
+      end
+
+      def init!
+        config = ::RuboCop::ConfigStore.new
+
+        @runtime = ::RuboCop::LSP::Runtime.new(config)
+      end
+
+      def run_diagnostic(uri, document)
+        @runtime.offenses(uri_to_path(uri), document.source, document.encoding)
+      end
+
+      def run_formatting(uri, document)
+        @runtime.format(uri_to_path(uri), document.source, command: 'rubocop.formatAutocorrects')
+      end
+
+      def run_range_formatting(_uri, _partial_source, _base_indentation)
+        # Not yet supported. Should return the formatted version of `partial_source` which is
+        # a partial selection of the entire document. For example, it should not try to add
+        # a frozen_string_literal magic comment and all style corrections should start from
+        # the `base_indentation`.
+        nil
+      end
+
+      private
+
+      # duplicated from: lib/standard/lsp/routes.rb
+      # modified to incorporate Ruby LSP's to_standardized_path method
+      def uri_to_path(uri)
+        if uri.respond_to?(:to_standardized_path) && (standardized_path = uri.to_standardized_path)
+          standardized_path
+        else
+          uri.to_s.delete_prefix('file://')
+        end
+      end
+    end
+  end
+end