ruby-lsp 0.22.1 → 0.23.10

data/lib/ruby_indexer/test/uri_test.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class URITest < Minitest::Test
+    def test_from_path_on_unix
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_equal("/some/unix/path/to/file.rb", uri.path)
+    end
+
+    def test_from_path_on_windows
+      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
+      assert_equal("/C:/some/windows/path/to/file.rb", uri.path)
+    end
+
+    def test_from_path_on_windows_with_lowercase_drive
+      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
+      assert_equal("/c:/some/windows/path/to/file.rb", uri.path)
+    end
+
+    def test_to_standardized_path_on_unix
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_equal(uri.path, uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows
+      uri = URI::Generic.from_path(path: "C:/some/windows/path/to/file.rb")
+      assert_equal("C:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows_with_lowercase_drive
+      uri = URI::Generic.from_path(path: "c:/some/windows/path/to/file.rb")
+      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_to_standardized_path_on_windows_with_received_uri
+      uri = URI("file:///c%3A/some/windows/path/to/file.rb")
+      assert_equal("c:/some/windows/path/to/file.rb", uri.to_standardized_path)
+    end
+
+    def test_plus_signs_are_properly_unescaped
+      path = "/opt/rubies/3.3.0/lib/ruby/3.3.0+0/pathname.rb"
+      uri = URI::Generic.from_path(path: path)
+      assert_equal(path, uri.to_standardized_path)
+    end
+
+    def test_from_path_with_fragment
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", fragment: "L1,3-2,9")
+      assert_equal("file:///some/unix/path/to/file.rb#L1,3-2,9", uri.to_s)
+    end
+
+    def test_from_path_windows_long_file_paths
+      uri = URI::Generic.from_path(path: "//?/C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb")
+      assert_equal("C:/hostedtoolcache/windows/Ruby/3.3.1/x64/lib/ruby/3.3.0/open-uri.rb", uri.to_standardized_path)
+    end
+
+    def test_from_path_computes_require_path_when_load_path_entry_is_given
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb", load_path_entry: "/some/unix/path")
+      assert_equal("to/file", uri.require_path)
+    end
+
+    def test_allows_adding_require_path_with_load_path_entry
+      uri = URI::Generic.from_path(path: "/some/unix/path/to/file.rb")
+      assert_nil(uri.require_path)
+
+      uri.add_require_path_from_load_entry("/some/unix/path")
+      assert_equal("to/file", uri.require_path)
+    end
+  end
+end

data/lib/ruby_lsp/addon.rb

@@ -97,6 +97,15 @@ module RubyLsp
         errors
       end
 
+      # Unloads all add-ons. Only intended to be invoked once when shutting down the Ruby LSP server
+      sig { void }
+      def unload_addons
+        @addons.each(&:deactivate)
+        @addons.clear
+        @addon_classes.clear
+        @file_watcher_addons.clear
+      end
+
       # Get a reference to another add-on object by name and version. If an add-on exports an API that can be used by
       # other add-ons, this is the way to get access to that API.
       #

data/lib/ruby_lsp/base_server.rb

@@ -18,22 +18,21 @@ module RubyLsp
       @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
       @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
       @cancelled_requests = T.let([], T::Array[Integer])
-      @mutex = T.let(Mutex.new, Mutex)
       @worker = T.let(new_worker, Thread)
       @current_request_id = T.let(1, Integer)
-      @store = T.let(Store.new, Store)
+      @global_state = T.let(GlobalState.new, GlobalState)
+      @store = T.let(Store.new(@global_state), Store)
       @outgoing_dispatcher = T.let(
         Thread.new do
           unless @test_mode
             while (message = @outgoing_queue.pop)
-              @mutex.synchronize { @writer.write(message.to_hash) }
+              @global_state.synchronize { @writer.write(message.to_hash) }
             end
           end
         end,
         Thread,
       )
 
-      @global_state = T.let(GlobalState.new, GlobalState)
       Thread.main.priority = 1
 
       # We read the initialize request in `exe/ruby-lsp` to be able to determine the workspace URI where Bundler should
@@ -51,7 +50,7 @@ module RubyLsp
         # source. Altering the source reference during parsing will put the parser in an invalid internal state, since
         # it started parsing with one source but then it changed in the middle. We don't want to do this for text
         # synchronization notifications
-        @mutex.synchronize do
+        @global_state.synchronize do
           uri = message.dig(:params, :textDocument, :uri)
 
           if uri
@@ -94,20 +93,14 @@ module RubyLsp
         when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
           process_message(message)
         when "shutdown"
-          send_log_message("Shutting down Ruby LSP...")
-
-          shutdown
-
-          @mutex.synchronize do
+          @global_state.synchronize do
+            send_log_message("Shutting down Ruby LSP...")
+            shutdown
             run_shutdown
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
         when "exit"
-          @mutex.synchronize do
-            status = @incoming_queue.closed? ? 0 : 1
-            send_log_message("Shutdown complete with status #{status}")
-            exit(status)
-          end
+          @global_state.synchronize { exit(@incoming_queue.closed? ? 0 : 1) }
         else
           @incoming_queue << message
         end
@@ -122,8 +115,8 @@ module RubyLsp
       @outgoing_queue.close
       @cancelled_requests.clear
 
-      @worker.join
-      @outgoing_dispatcher.join
+      @worker.terminate
+      @outgoing_dispatcher.terminate
       @store.clear
     end
 
@@ -133,6 +126,12 @@ module RubyLsp
       @outgoing_queue.pop
     end
 
+    # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def push_message(message)
+      @incoming_queue << message
+    end
+
     sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
     def process_message(message); end
 
@@ -152,7 +151,7 @@ module RubyLsp
           id = message[:id]
 
           # Check if the request was cancelled before trying to process it
-          @mutex.synchronize do
+          @global_state.synchronize do
             if id && @cancelled_requests.include?(id)
               send_message(Result.new(id: id, response: nil))
               @cancelled_requests.delete(id)

data/lib/ruby_lsp/client_capabilities.rb

@@ -11,7 +11,8 @@ module RubyLsp
     attr_reader :supports_watching_files,
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
-      :supports_progress
+      :supports_progress,
+      :supports_diagnostic_refresh
 
     sig { void }
     def initialize
@@ -32,6 +33,9 @@ module RubyLsp
 
       # The editor supports displaying progress requests
       @supports_progress = T.let(false, T::Boolean)
+
+      # The editor supports server initiated refresh for diagnostics
+      @supports_diagnostic_refresh = T.let(false, T::Boolean)
     end
 
     sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
@@ -57,6 +61,8 @@ module RubyLsp
 
       progress = capabilities.dig(:window, :workDoneProgress)
       @supports_progress = progress if progress
+
+      @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/document.rb

@@ -15,6 +15,7 @@ module RubyLsp
     extend T::Helpers
     extend T::Generic
 
+    class LocationNotFoundError < StandardError; end
     ParseResultType = type_member
 
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
@@ -39,19 +40,24 @@ module RubyLsp
     sig { returns(Encoding) }
     attr_reader :encoding
 
+    sig { returns(T.nilable(Edit)) }
+    attr_reader :last_edit
+
     sig { returns(T.any(Interface::SemanticTokens, Object)) }
     attr_accessor :semantic_tokens
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
+      @source = source
+      @version = version
+      @global_state = global_state
       @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
       @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
-      @encoding = T.let(encoding, Encoding)
-      @source = T.let(source, String)
-      @version = T.let(version, Integer)
+      @encoding = T.let(global_state.encoding, Encoding)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
       @parse_result = T.let(T.unsafe(nil), ParseResultType)
+      @last_edit = T.let(nil, T.nilable(Edit))
       parse!
     end
 
@@ -63,7 +69,6 @@ module RubyLsp
     sig { abstract.returns(LanguageId) }
     def language_id; end
 
-    # TODO: remove this method once all non-positional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
         .params(
@@ -105,6 +110,19 @@ module RubyLsp
       @version = version
       @needs_parsing = true
       @cache.clear
+
+      last_edit = edits.last
+      return unless last_edit
+
+      last_edit_range = last_edit[:range]
+
+      @last_edit = if last_edit_range[:start] == last_edit_range[:end]
+        Insert.new(last_edit_range)
+      elsif last_edit[:text].empty?
+        Delete.new(last_edit_range)
+      else
+        Replace.new(last_edit_range)
+      end
     end
 
     # Returns `true` if the document was parsed and `false` if nothing needed parsing
@@ -114,16 +132,52 @@ module RubyLsp
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end
 
+    sig { returns(T::Boolean) }
+    def past_expensive_limit?
+      @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
+    end
+
+    sig do
+      params(
+        start_pos: T::Hash[Symbol, T.untyped],
+        end_pos: T.nilable(T::Hash[Symbol, T.untyped]),
+      ).returns([Integer, T.nilable(Integer)])
+    end
+    def find_index_by_position(start_pos, end_pos = nil)
+      @global_state.synchronize do
+        scanner = create_scanner
+        start_index = scanner.find_char_position(start_pos)
+        end_index = scanner.find_char_position(end_pos) if end_pos
+        [start_index, end_index]
+      end
+    end
+
+    private
+
     sig { returns(Scanner) }
     def create_scanner
       Scanner.new(@source, @encoding)
     end
 
-    sig { returns(T::Boolean) }
-    def past_expensive_limit?
-      @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
+    class Edit
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :range
+
+      sig { params(range: T::Hash[Symbol, T.untyped]).void }
+      def initialize(range)
+        @range = range
+      end
     end
 
+    class Insert < Edit; end
+    class Replace < Edit; end
+    class Delete < Edit; end
+
     class Scanner
       extend T::Sig
 
@@ -144,7 +198,15 @@ module RubyLsp
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
-          @pos += 1 until LINE_BREAK == @source[@pos]
+          until LINE_BREAK == @source[@pos]
+            @pos += 1
+
+            if @pos >= @source.length
+              # Pack the code points back into the original string to provide context in the error message
+              raise LocationNotFoundError, "Requested position: #{position}\nSource:\n\n#{@source.pack("U*")}"
+            end
+          end
+
           @pos += 1
           @current_line += 1
         end

data/lib/ruby_lsp/erb_document.rb

@@ -19,8 +19,8 @@ module RubyLsp
     end
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
-    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
       @host_language_source = T.let("", String)
@@ -63,9 +63,11 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
+      char_position, _ = find_index_by_position(position)
+
       RubyDocument.locate(
         @parse_result.value,
-        create_scanner.find_char_position(position),
+        char_position,
         code_units_cache: @code_units_cache,
         node_types: node_types,
       )

data/lib/ruby_lsp/global_state.rb

@@ -29,6 +29,12 @@ module RubyLsp
     sig { returns(ClientCapabilities) }
     attr_reader :client_capabilities
 
+    sig { returns(URI::Generic) }
+    attr_reader :workspace_uri
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :telemetry_machine_id
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
@@ -53,6 +59,13 @@ module RubyLsp
       )
       @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
       @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
+      @mutex = T.let(Mutex.new, Mutex)
+      @telemetry_machine_id = T.let(nil, T.nilable(String))
+    end
+
+    sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
 
     sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
@@ -85,6 +98,8 @@ module RubyLsp
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
+      rubocop_has_addon = defined?(::RuboCop::Version::STRING) &&
+        Gem::Requirement.new(">= 1.70.0").satisfied_by?(Gem::Version.new(::RuboCop::Version::STRING))
 
       if specified_formatter
         @formatter = specified_formatter
@@ -92,6 +107,12 @@ module RubyLsp
         if specified_formatter != "auto"
           notifications << Notification.window_log_message("Using formatter specified by user: #{@formatter}")
         end
+
+        # If the user had originally configured to use `rubocop`, but their version doesn't provide the add-on yet,
+        # fallback to the internal integration
+        if specified_formatter == "rubocop" && !rubocop_has_addon
+          @formatter = "rubocop_internal"
+        end
       end
 
       if @formatter == "auto"
@@ -100,6 +121,23 @@ module RubyLsp
       end
 
       specified_linters = options.dig(:initializationOptions, :linters)
+
+      if specified_formatter == "rubocop" || specified_linters&.include?("rubocop")
+        notifications << Notification.window_log_message(<<~MESSAGE, type: Constant::MessageType::WARNING)
+          Formatter is configured to be `rubocop`. As of RuboCop v1.70.0, this identifier activates the add-on
+          implemented in the rubocop gem itself instead of the internal integration provided by the Ruby LSP.
+
+          If you wish to use the internal integration, please configure the formatter as `rubocop_internal`.
+        MESSAGE
+      end
+
+      # If the user had originally configured to use `rubocop`, but their version doesn't provide the add-on yet,
+      # fall back to the internal integration
+      if specified_linters&.include?("rubocop") && !rubocop_has_addon
+        specified_linters.delete("rubocop")
+        specified_linters << "rubocop_internal"
+      end
+
       @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
 
       notifications << if specified_linters
@@ -141,6 +179,7 @@ module RubyLsp
       enabled_flags = options.dig(:initializationOptions, :enabledFeatureFlags)
       @enabled_feature_flags = enabled_flags if enabled_flags
 
+      @telemetry_machine_id = options.dig(:initializationOptions, :telemetryMachineId)
       notifications
     end
 
@@ -176,13 +215,13 @@ module RubyLsp
     sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      return "rubocop" if direct_dependencies.any?(/^rubocop/)
+      return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
 
       syntax_tree_is_direct_dependency = direct_dependencies.include?("syntax_tree")
       return "syntax_tree" if syntax_tree_is_direct_dependency
 
       rubocop_is_transitive_dependency = all_dependencies.include?("rubocop")
-      return "rubocop" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
+      return "rubocop_internal" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
 
       "none"
     end
@@ -194,7 +233,7 @@ module RubyLsp
       linters = []
 
       if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
-        linters << "rubocop"
+        linters << "rubocop_internal"
       end
 
       linters

data/lib/ruby_lsp/internal.rb

@@ -22,11 +22,12 @@ require "prism/visitor"
 require "language_server-protocol"
 require "rbs"
 require "fileutils"
+require "open3"
+require "securerandom"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
-require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/static_docs"
 require "ruby_lsp/scope"
@@ -78,6 +79,7 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/prepare_rename"
 require "ruby_lsp/requests/range_formatting"
 require "ruby_lsp/requests/references"
 require "ruby_lsp/requests/rename"

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -15,7 +15,7 @@ module RubyLsp
           "bundle exec ruby"
         rescue Bundler::GemfileNotFound
           "ruby"
-        end + " -Itest ",
+        end,
         String,
       )
       ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
@@ -198,7 +198,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run",
+          title: "▶ Run",
           command_name: "rubyLsp.runTest",
           arguments: arguments,
           data: { type: "test", **grouping_data },
@@ -206,7 +206,7 @@ module RubyLsp
 
         @response_builder << create_code_lens(
           node,
-          title: "Run In Terminal",
+          title: "▶ Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
           arguments: arguments,
           data: { type: "test_in_terminal", **grouping_data },
@@ -229,7 +229,11 @@ module RubyLsp
         ).returns(String)
       end
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
-        command = BASE_COMMAND + T.must(@path)
+        path = T.must(@path)
+        command = BASE_COMMAND
+        command += " -Itest" if File.fnmatch?("**/test/**/*", path, File::FNM_PATHNAME)
+        command += " -Ispec" if File.fnmatch?("**/spec/**/*", path, File::FNM_PATHNAME)
+        command += " #{path}"
 
         case @global_state.test_library
         when "minitest"
@@ -282,7 +286,7 @@ module RubyLsp
         when Prism::StringNode
           first_argument.content
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          constant_name(first_argument)
+          RubyIndexer::Index.constant_name(first_argument)
         end
 
         return unless name