ruby-lsp 0.22.0 → 0.23.0

data/lib/ruby_indexer/test/index_test.rb

@@ -6,11 +6,11 @@ require_relative "test_case"
 module RubyIndexer
   class IndexTest < TestCase
     def test_deleting_one_entry_for_a_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new(nil, "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -18,13 +18,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(2, entries.length)
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/other_foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/other_foo.rb"))
       entries = @index["Foo"]
       assert_equal(1, entries.length)
     end
 
     def test_deleting_all_entries_for_a_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -32,13 +32,13 @@ module RubyIndexer
       entries = @index["Foo"]
       assert_equal(1, entries.length)
 
-      @index.delete(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.delete(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries = @index["Foo"]
       assert_nil(entries)
     end
 
     def test_index_resolve
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -72,7 +72,7 @@ module RubyIndexer
     end
 
     def test_accessing_with_colon_colon_prefix
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -92,7 +92,7 @@ module RubyIndexer
     end
 
     def test_fuzzy_search
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Zws; end
 
         module Qtl
@@ -120,18 +120,22 @@ module RubyIndexer
     end
 
     def test_index_single_ignores_directories
-      FileUtils.mkdir("lib/this_is_a_dir.rb")
-      @index.index_single(IndexablePath.new(nil, "lib/this_is_a_dir.rb"))
-    ensure
-      FileUtils.rm_r("lib/this_is_a_dir.rb")
+      path = "#{Dir.pwd}/lib/this_is_a_dir.rb"
+      FileUtils.mkdir(path)
+
+      begin
+        @index.index_file(URI::Generic.from_path(path: path))
+      ensure
+        FileUtils.rm_r(path)
+      end
     end
 
     def test_searching_for_require_paths
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo
         end
       RUBY
@@ -140,11 +144,11 @@ module RubyIndexer
     end
 
     def test_searching_for_entries_based_on_prefix
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
       RUBY
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/other_foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/other_foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Foo::Bizw
         end
 
@@ -160,7 +164,7 @@ module RubyIndexer
     end
 
     def test_resolve_normalizes_top_level_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar; end
 
         module Foo
@@ -180,7 +184,7 @@ module RubyIndexer
     end
 
     def test_resolving_aliases_to_non_existing_constants_with_conflicting_names
-      @index.index_single(IndexablePath.new("/fake", "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb", load_path_entry: "/fake"), <<~RUBY)
         class Bar
         end
 
@@ -343,18 +347,18 @@ module RubyIndexer
         raise "Prism fixtures not found. Run `git submodule update --init` to fetch them."
       end
 
-      fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
+      fixtures = Dir.glob("#{Dir.pwd}/test/fixtures/prism/test/prism/fixtures/**/*.txt")
 
       fixtures.each do |fixture|
-        indexable_path = IndexablePath.new("", fixture)
-        @index.index_single(indexable_path)
+        uri = URI::Generic.from_path(path: fixture)
+        @index.index_file(uri)
       end
 
       refute_empty(@index)
     end
 
     def test_index_single_does_not_fail_for_non_existing_file
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      @index.index_file(URI::Generic.from_path(path: "/fake/path/foo.rb"))
       entries_after_indexing = @index.names
       assert_equal(@default_indexed_entries.keys, entries_after_indexing)
     end
@@ -782,8 +786,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -796,7 +800,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -816,8 +820,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -833,7 +837,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           refute_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -852,8 +856,8 @@ module RubyIndexer
             end
           RUBY
 
-          indexable_path = IndexablePath.new(nil, File.join(dir, "foo.rb"))
-          @index.index_single(indexable_path)
+          uri = URI::Generic.from_path(path: File.join(dir, "foo.rb"))
+          @index.index_file(uri)
 
           assert_equal(["Bar", "Foo", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
 
@@ -866,7 +870,7 @@ module RubyIndexer
             end
           RUBY
 
-          @index.handle_change(indexable_path)
+          @index.handle_change(uri, File.read(T.must(uri.full_path)))
           assert_empty(@index.instance_variable_get(:@ancestors))
           assert_equal(["Bar", "Object", "Kernel", "BasicObject"], @index.linearized_ancestors_of("Bar"))
         end
@@ -1300,7 +1304,7 @@ module RubyIndexer
     end
 
     def test_resolving_method_inside_singleton_context
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             class << self
@@ -1321,7 +1325,7 @@ module RubyIndexer
     end
 
     def test_resolving_constants_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             CONST = 3
@@ -1346,7 +1350,7 @@ module RubyIndexer
     end
 
     def test_resolving_instance_variables_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1376,7 +1380,7 @@ module RubyIndexer
     end
 
     def test_instance_variable_completion_in_singleton_contexts
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           class Bar
             @a = 123
@@ -1622,7 +1626,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_of_singleton_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1673,7 +1677,7 @@ module RubyIndexer
     end
 
     def test_extend_self
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module Foo
           def bar
           end
@@ -1705,7 +1709,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module First
         end
 
@@ -1746,7 +1750,7 @@ module RubyIndexer
     end
 
     def test_linearizing_singleton_ancestors_when_class_has_parent
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         class Foo; end
 
         class Bar < Foo
@@ -1776,7 +1780,7 @@ module RubyIndexer
     end
 
     def test_linearizing_a_module_singleton_class
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), <<~RUBY)
+      @index.index_single(URI::Generic.from_path(path: "/fake/path/foo.rb"), <<~RUBY)
         module A; end
       RUBY
 
@@ -1885,13 +1889,13 @@ module RubyIndexer
         end
       RUBY
 
-      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      entries = @index.entries_for("file:///fake/path/foo.rb", Entry)
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
 
-      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      entries = @index.entries_for("file:///fake/path/foo.rb", RubyIndexer::Entry::Namespace)
       assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
 
-      entries = @index.entries_for("/fake/path/foo.rb")
+      entries = @index.entries_for("file:///fake/path/foo.rb")
       assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
     end
 
@@ -2062,5 +2066,30 @@ module RubyIndexer
         @index.index_all
       end
     end
+
+    def test_index_can_handle_entries_from_untitled_scheme
+      uri = URI("untitled:Untitled-1")
+
+      index(<<~RUBY, uri: uri)
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("untitled:Untitled-1", entry.uri.to_s)
+      assert_equal("Untitled-1", entry.file_name)
+      assert_nil(entry.file_path)
+
+      @index.handle_change(uri, <<~RUBY)
+        # I added this comment!
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"]&.first
+      refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
+      assert_equal("I added this comment!", entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -149,6 +149,86 @@ module RubyIndexer
       end
     end
 
+    def test_private_class_method_visibility_tracking_string_symbol_arguments
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method("foo", :bar)
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_array_argument
+      index(<<~RUBY)
+        class Test
+          def self.foo
+          end
+
+          def self.bar
+          end
+
+          private_class_method(["foo", :bar])
+
+          def self.baz
+          end
+        end
+      RUBY
+
+      ["foo", "bar"].each do |keyword|
+        entries = T.must(@index[keyword])
+        assert_equal(1, entries.size)
+        entry = entries.first
+        assert_predicate(entry, :private?)
+      end
+
+      entries = T.must(@index["baz"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
+    def test_private_class_method_visibility_tracking_method_argument
+      index(<<~RUBY)
+        class Test
+          private_class_method def self.foo
+          end
+
+          def self.bar
+          end
+        end
+      RUBY
+
+      entries = T.must(@index["foo"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :private?)
+
+      entries = T.must(@index["bar"])
+      assert_equal(1, entries.size)
+      entry = entries.first
+      assert_predicate(entry, :public?)
+    end
+
     def test_comments_documentation
       index(<<~RUBY)
         # Documentation for Foo

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -377,7 +377,7 @@ module RubyIndexer
       _, _, declarations = RBS::Parser.parse_signature(buffer)
       index = RubyIndexer::Index.new
       indexer = RubyIndexer::RBSIndexer.new(index)
-      pathname = Pathname.new("file.rbs")
+      pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
       entry = T.must(index[method_name]).first
       T.cast(entry, Entry::Method).signatures

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -231,7 +231,7 @@ module RubyIndexer
     def find_references(target, source)
       file_path = "/fake.rb"
       index = Index.new
-      index.index_single(IndexablePath.new(nil, file_path), source)
+      index.index_single(URI::Generic.from_path(path: file_path), source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
       finder = ReferenceFinder.new(target, index, dispatcher)

data/lib/ruby_indexer/test/test_case.rb

@@ -13,8 +13,8 @@ module RubyIndexer
 
     private
 
-    def index(source)
-      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
+    def index(source, uri: URI::Generic.from_path(path: "/fake/path/foo.rb"))
+      @index.index_single(uri, source)
     end
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)

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

@@ -91,14 +91,13 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+             "$/cancelRequest"
           process_message(message)
         when "shutdown"
-          send_log_message("Shutting down Ruby LSP...")
-
-          shutdown
-
           @mutex.synchronize do
+            send_log_message("Shutting down Ruby LSP...")
+            shutdown
             run_shutdown
             @writer.write(Result.new(id: message[:id], response: nil).to_hash)
           end
@@ -133,6 +132,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
 
@@ -154,7 +159,11 @@ module RubyLsp
           # Check if the request was cancelled before trying to process it
           @mutex.synchronize do
             if id && @cancelled_requests.include?(id)
-              send_message(Result.new(id: id, response: nil))
+              send_message(Error.new(
+                id: id,
+                code: Constant::ErrorCodes::REQUEST_CANCELLED,
+                message: "Request #{id} was cancelled",
+              ))
               @cancelled_requests.delete(id)
               next
             end

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.
@@ -144,7 +145,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/global_state.rb

@@ -146,7 +146,7 @@ module RubyLsp
 
     sig { params(flag: Symbol).returns(T.nilable(T::Boolean)) }
     def enabled_feature?(flag)
-      @enabled_feature_flags[flag]
+      @enabled_feature_flags[:all] || @enabled_feature_flags[flag]
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/internal.rb

@@ -26,7 +26,6 @@ require "fileutils"
 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 +77,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"