ruby-lsp 0.23.9 → 0.23.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 149e7978a6f85c9349fa3922283a151f2e2129d12eb14e29d665ad35a3b909e7
-  data.tar.gz: a931c7b049810fe304eaa93ae4a7a8bdd499951fa9f3ca21b6da9df91cc24e12
+  metadata.gz: b93894c0d2c2687def87d9e173c7a9e45e810088613cb902c2a4b1a9d93a8404
+  data.tar.gz: 9e92f360c8367cde864ac1a5dd2305170a975fa3164e6fc2c1d6f492396fbbc5
 SHA512:
-  metadata.gz: 6fae90263d8e037d3e58a0f20de4e6eaa671d739f28fa1af90a013a9d0ade3a43fa118b5fe15c3e2a3de025a9c3e4a53dc4584426678619896b98d38cca2dcbc
-  data.tar.gz: c634542b0ec26e9df418222b8eab459f42d3f65e42c196c6a3769139073c94f98bfb0da8cb61b18f055629aa9fbf58d6516d13a40b453f27fbc4a6f1514d3d9d
+  metadata.gz: fc2172fba1c50192cb86d2dfc619c633cf756f3ebb574caaaeabb81fe23d283b7b896f48fe23981d29c472fce98248137171d119b33c75d1a7f6fafc73c7a775
+  data.tar.gz: 03b0b5987fc8dcc6c989ce6c5df55e16fff906836ef74aa993ddc445b50c5d3458775fee1a31b9e228710df44f80b8338390ef1fdf75d464deac4e38fe822644

data/VERSION

@@ -1 +1 @@
-0.23.9
+0.23.11

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -87,7 +87,7 @@ module RubyIndexer
         # Find the group that is either immediately or two lines above the current entry
         correct_group = grouped.find do |group|
           comment_end_line = group.last.location.start_line
-          (comment_end_line - 1..comment_end_line).cover?(@location.start_line - 1)
+          (comment_end_line..comment_end_line + 1).cover?(@location.start_line - 1)
         end
 
         # If we found something, we join the comments together. Otherwise, the entry has no documentation and we don't

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -21,9 +21,9 @@ module RubyIndexer
       # Returns the real nesting of a constant name taking into account top level
       # references that may be included anywhere in the name or nesting where that
       # constant was found
-      sig { params(stack: T::Array[String], name: String).returns(T::Array[String]) }
+      sig { params(stack: T::Array[String], name: T.nilable(String)).returns(T::Array[String]) }
       def actual_nesting(stack, name)
-        nesting = stack + [name]
+        nesting = name ? stack + [name] : stack
         corrected_nesting = []
 
         nesting.reverse_each do |name|
@@ -43,11 +43,18 @@ module RubyIndexer
             Prism::ConstantPathNode,
             Prism::ConstantReadNode,
             Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::MissingNode,
           ),
         ).returns(T.nilable(String))
       end
       def constant_name(node)
-        node.full_name
+        case node
+        when Prism::CallNode, Prism::MissingNode
+          nil
+        else
+          node.full_name
+        end
       rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
              Prism::ConstantPathNode::MissingNodesInConstantPathError
         nil

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -666,5 +666,80 @@ module RubyIndexer
       method = @index["baz"]&.first
       assert_equal("Foo::Bar::<Class:Bar>", method.owner.name)
     end
+
+    def test_lazy_comments_with_spaces_are_properly_attributed
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source =  <<~RUBY
+        require "whatever"
+
+        # These comments belong to the declaration below
+        # They have to be associated with it
+
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_equal(<<~COMMENTS.chomp, entry.comments)
+          These comments belong to the declaration below
+          They have to be associated with it
+        COMMENTS
+      ensure
+        FileUtils.rm(path)
+      end
+    end
+
+    def test_lazy_comments_with_no_spaces_are_properly_attributed
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source = <<~RUBY
+        require "whatever"
+
+        # These comments belong to the declaration below
+        # They have to be associated with it
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_equal(<<~COMMENTS.chomp, entry.comments)
+          These comments belong to the declaration below
+          They have to be associated with it
+        COMMENTS
+      ensure
+        FileUtils.rm(path)
+      end
+    end
+
+    def test_lazy_comments_with_two_extra_spaces_are_properly_ignored
+      path = File.join(Dir.pwd, "lib", "foo.rb")
+      source = <<~RUBY
+        require "whatever"
+
+        # These comments don't belong to the declaration below
+        # They will not be associated with it
+
+
+        class Foo
+        end
+      RUBY
+      File.write(path, source)
+      @index.index_single(URI::Generic.from_path(path: path), source, collect_comments: false)
+
+      entry = @index["Foo"].first
+
+      begin
+        assert_empty(entry.comments)
+      ensure
+        FileUtils.rm(path)
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -2161,5 +2161,26 @@ module RubyIndexer
 
       assert_equal("@@hello", candidates.first&.name)
     end
+
+    def test_actual_nesting
+      assert_equal(["Foo"], Index.actual_nesting([], "Foo"))
+      assert_equal(["TopLevel", "Foo"], Index.actual_nesting(["First", "::TopLevel"], "Foo"))
+      assert_equal(["TopLevel", "Another", "Foo"], Index.actual_nesting(["::TopLevel", "Another"], "Foo"))
+      assert_equal(["TopLevel"], Index.actual_nesting(["First", "::TopLevel"], nil))
+    end
+
+    def test_constant_name
+      node = Prism.parse("class var::Foo; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class ; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class method_call; end").value.statements.body.first.constant_path
+      assert_nil(Index.constant_name(node))
+
+      node = Prism.parse("class Foo; end").value.statements.body.first.constant_path
+      assert_equal("Foo", Index.constant_name(node))
+    end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -90,7 +90,8 @@ 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",
+          "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do

data/lib/ruby_lsp/global_state.rb

@@ -32,6 +32,9 @@ module RubyLsp
     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)
@@ -57,6 +60,7 @@ 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)) }
@@ -175,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
 

data/lib/ruby_lsp/internal.rb

@@ -24,6 +24,7 @@ require "rbs"
 require "fileutils"
 require "open3"
 require "securerandom"
+require "shellwords"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"
@@ -50,6 +51,7 @@ require "ruby_lsp/response_builders/document_symbol"
 require "ruby_lsp/response_builders/hover"
 require "ruby_lsp/response_builders/semantic_highlighting"
 require "ruby_lsp/response_builders/signature_help"
+require "ruby_lsp/response_builders/test_collection"
 
 # Request support
 require "ruby_lsp/requests/support/selection_range"
@@ -60,6 +62,7 @@ require "ruby_lsp/requests/support/formatter"
 require "ruby_lsp/requests/support/rubocop_runner"
 require "ruby_lsp/requests/support/rubocop_formatter"
 require "ruby_lsp/requests/support/syntax_tree_formatter"
+require "ruby_lsp/requests/support/test_item"
 
 # Requests
 require "ruby_lsp/requests/request"
@@ -70,6 +73,7 @@ require "ruby_lsp/requests/completion_resolve"
 require "ruby_lsp/requests/completion"
 require "ruby_lsp/requests/definition"
 require "ruby_lsp/requests/diagnostics"
+require "ruby_lsp/requests/discover_tests"
 require "ruby_lsp/requests/document_highlight"
 require "ruby_lsp/requests/document_link"
 require "ruby_lsp/requests/document_symbol"

data/lib/ruby_lsp/listeners/completion.rb

@@ -471,6 +471,9 @@ module RubyLsp
             path_node_to_complete,
           )
         end
+      rescue Errno::EPERM
+        # If the user writes a relative require pointing to a path that the editor has no permissions to read, then glob
+        # might fail with EPERM
       end
 
       sig { params(node: Prism::CallNode, name: String).void }

data/lib/ruby_lsp/listeners/test_style.rb

@@ -0,0 +1,164 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Listeners
+    class TestStyle
+      extend T::Sig
+      include Requests::Support::Common
+
+      ACCESS_MODIFIERS = [:public, :private, :protected].freeze
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>"
+
+      sig do
+        params(
+          response_builder: ResponseBuilders::TestCollection,
+          global_state: GlobalState,
+          dispatcher: Prism::Dispatcher,
+          uri: URI::Generic,
+        ).void
+      end
+      def initialize(response_builder, global_state, dispatcher, uri)
+        @response_builder = response_builder
+        @uri = uri
+        @index = T.let(global_state.index, RubyIndexer::Index)
+        @visibility_stack = T.let([:public], T::Array[Symbol])
+        @nesting = T.let([], T::Array[String])
+
+        dispatcher.register(
+          self,
+          :on_class_node_enter,
+          :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
+          :on_def_node_enter,
+          :on_call_node_enter,
+          :on_call_node_leave,
+        )
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_enter(node)
+        @visibility_stack << :public
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        fully_qualified_name = RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+
+        attached_ancestors = begin
+          @index.linearized_ancestors_of(fully_qualified_name)
+        rescue RubyIndexer::Index::NonExistingNamespaceError
+          # When there are dynamic parts in the constant path, we will not have indexed the namespace. We can still
+          # provide test functionality if the class inherits directly from Test::Unit::TestCase or Minitest::Test
+          [node.superclass&.slice].compact
+        end
+
+        if attached_ancestors.include?("Test::Unit::TestCase") ||
+            non_declarative_minitest?(attached_ancestors, fully_qualified_name)
+
+          @response_builder.add(Requests::Support::TestItem.new(
+            fully_qualified_name,
+            fully_qualified_name,
+            @uri,
+            range_from_node(node),
+          ))
+        end
+
+        @nesting << name
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        @visibility_stack << :public
+
+        name = constant_name(node.constant_path)
+        name ||= name_with_dynamic_reference(node.constant_path)
+
+        @nesting << name
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      sig { params(node: Prism::ClassNode).void }
+      def on_class_node_leave(node)
+        @visibility_stack.pop
+        @nesting.pop
+      end
+
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_enter(node)
+        return if @visibility_stack.last != :public
+
+        name = node.name.to_s
+        return unless name.start_with?("test_")
+
+        current_group_name = RubyIndexer::Index.actual_nesting(@nesting, nil).join("::")
+
+        # If we're finding a test method, but for the wrong framework, then the group test item will not have been
+        # previously pushed and thus we return early and avoid adding items for a framework this listener is not
+        # interested in
+        test_item = @response_builder[current_group_name]
+        return unless test_item
+
+        test_item.add(Requests::Support::TestItem.new(
+          "#{current_group_name}##{name}",
+          name,
+          @uri,
+          range_from_node(node),
+        ))
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        name = node.name
+        return unless ACCESS_MODIFIERS.include?(name)
+
+        @visibility_stack << name
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_leave(node)
+        name = node.name
+        return unless ACCESS_MODIFIERS.include?(name)
+        return unless node.arguments&.arguments
+
+        @visibility_stack.pop
+      end
+
+      private
+
+      sig { params(attached_ancestors: T::Array[String], fully_qualified_name: String).returns(T::Boolean) }
+      def non_declarative_minitest?(attached_ancestors, fully_qualified_name)
+        return false unless attached_ancestors.include?("Minitest::Test")
+
+        # We only support regular Minitest tests. The declarative syntax provided by ActiveSupport is handled by the
+        # Rails add-on
+        name_parts = fully_qualified_name.split("::")
+        singleton_name = "#{name_parts.join("::")}::<Class:#{name_parts.last}>"
+        !@index.linearized_ancestors_of(singleton_name).include?("ActiveSupport::Testing::Declarative")
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        true
+      end
+
+      sig do
+        params(
+          node: T.any(
+            Prism::ConstantPathNode,
+            Prism::ConstantReadNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::MissingNode,
+          ),
+        ).returns(String)
+      end
+      def name_with_dynamic_reference(node)
+        slice = node.slice
+        slice.gsub(/((?<=::)|^)[a-z]\w*/, DYNAMIC_REFERENCE_MARKER)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/listeners/test_style"
+
+module RubyLsp
+  module Requests
+    # This is a custom request to ask the server to parse a test file and discover all available examples in it. Add-ons
+    # can augment the behavior through listeners, allowing them to handle discovery for different frameworks
+    class DiscoverTests < Request
+      extend T::Sig
+      include Support::Common
+
+      sig { params(global_state: GlobalState, document: RubyDocument, dispatcher: Prism::Dispatcher).void }
+      def initialize(global_state, document, dispatcher)
+        super()
+        @global_state = global_state
+        @document = document
+        @dispatcher = dispatcher
+        @response_builder = T.let(ResponseBuilders::TestCollection.new, ResponseBuilders::TestCollection)
+        @index = T.let(global_state.index, RubyIndexer::Index)
+      end
+
+      sig { override.returns(T::Array[Support::TestItem]) }
+      def perform
+        uri = @document.uri
+
+        # We normally only index test files once they are opened in the editor to save memory and avoid doing
+        # unnecessary work. If the file is already opened and we already indexed it, then we can just discover the tests
+        # straight away.
+        #
+        # However, if the user navigates to a specific test file from the explorer with nothing opened in the UI, then
+        # we will not have indexed the test file yet and trying to linearize the ancestor of the class will fail. In
+        # this case, we have to instantiate the indexer listener first, so that we insert classes, modules and methods
+        # in the index first and then discover the tests, all in the same traversal.
+        if @index.entries_for(uri.to_s)
+          Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+          @dispatcher.visit(@document.parse_result.value)
+        else
+          @global_state.synchronize do
+            RubyIndexer::DeclarationListener.new(
+              @index,
+              @dispatcher,
+              @document.parse_result,
+              uri,
+              collect_comments: true,
+            )
+
+            Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+            # Dispatch the events both for indexing the test file and discovering the tests. The order here is
+            # important because we need the index to be aware of the existing classes/modules/methods before the test
+            # listeners can do their work
+            @dispatcher.visit(@document.parse_result.value)
+          end
+        end
+
+        @response_builder.response
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/support/common.rb

@@ -141,6 +141,8 @@ module RubyLsp
               Prism::ConstantPathNode,
               Prism::ConstantReadNode,
               Prism::ConstantPathTargetNode,
+              Prism::CallNode,
+              Prism::MissingNode,
             ),
           ).returns(T.nilable(String))
         end

data/lib/ruby_lsp/requests/support/test_item.rb

@@ -0,0 +1,59 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      # Represents a test item as defined by the VS Code interface to be used in the test explorer
+      # See https://code.visualstudio.com/api/references/vscode-api#TestItem
+      #
+      # Note: this test item object can only represent test groups or examples discovered inside files. It cannot be
+      # used to represent test files, directories or workspaces
+      class TestItem
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :id, :label
+
+        sig { params(id: String, label: String, uri: URI::Generic, range: Interface::Range).void }
+        def initialize(id, label, uri, range)
+          @id = id
+          @label = label
+          @uri = uri
+          @range = range
+          @children = T.let({}, T::Hash[String, TestItem])
+        end
+
+        sig { params(item: TestItem).void }
+        def add(item)
+          if @children.key?(item.id)
+            raise ResponseBuilders::TestCollection::DuplicateIdError, "TestItem ID is already in use"
+          end
+
+          @children[item.id] = item
+        end
+
+        sig { params(id: String).returns(T.nilable(TestItem)) }
+        def [](id)
+          @children[id]
+        end
+
+        sig { returns(T::Array[TestItem]) }
+        def children
+          @children.values
+        end
+
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        def to_hash
+          {
+            id: @id,
+            label: @label,
+            uri: @uri,
+            range: @range,
+            children: children.map(&:to_hash),
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module ResponseBuilders
+    class TestCollection < ResponseBuilder
+      class DuplicateIdError < StandardError; end
+
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: Requests::Support::TestItem } }
+
+      sig { void }
+      def initialize
+        super
+        @items = T.let({}, T::Hash[String, ResponseType])
+      end
+
+      sig { params(item: ResponseType).void }
+      def add(item)
+        raise DuplicateIdError, "TestItem ID is already in use" if @items.key?(item.id)
+
+        @items[item.id] = item
+      end
+
+      sig { params(id: String).returns(T.nilable(ResponseType)) }
+      def [](id)
+        @items[id]
+      end
+
+      sig { override.returns(T::Array[ResponseType]) }
+      def response
+        @items.values
+      end
+    end
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -108,6 +108,10 @@ module RubyLsp
         )
       when "rubyLsp/composeBundle"
         compose_bundle(message)
+      when "rubyLsp/diagnoseState"
+        diagnose_state(message)
+      when "rubyLsp/discoverTests"
+        discover_tests(message)
       when "$/cancelRequest"
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
@@ -1032,7 +1036,14 @@ module RubyLsp
         end
       end
 
-      Addon.file_watcher_addons.each { |addon| T.unsafe(addon).workspace_did_change_watched_files(changes) }
+      Addon.file_watcher_addons.each do |addon|
+        T.unsafe(addon).workspace_did_change_watched_files(changes)
+      rescue => e
+        send_log_message(
+          "Error in #{addon.name} add-on while processing watched file notifications: #{e.full_message}",
+          type: Constant::MessageType::ERROR,
+        )
+      end
     end
 
     sig { params(index: RubyIndexer::Index, file_path: String, change_type: Integer).void }
@@ -1044,9 +1055,13 @@ module RubyLsp
 
       case change_type
       when Constant::FileChangeType::CREATED
-        index.index_single(uri, content)
+        # If we receive a late created notification for a file that has already been claimed by the client, we want to
+        # handle change for that URI so that the require path tree is updated
+        @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
       when Constant::FileChangeType::CHANGED
-        index.handle_change(uri, content)
+        # We only handle changes on file watched notifications if the client is not the one managing this URI.
+        # Otherwise, these changes are handled when running the combined requests
+        index.handle_change(uri, content) unless @store.key?(uri)
       when Constant::FileChangeType::DELETED
         index.delete(uri)
       end
@@ -1357,5 +1372,47 @@ module RubyLsp
         end
       end
     end
+
+    # Returns internal state information for debugging purposes
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def diagnose_state(message)
+      documents = {}
+      @store.each { |uri, document| documents[uri] = document.source }
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: {
+            workerAlive: @worker.alive?,
+            backtrace: @worker.backtrace,
+            documents: documents,
+            incomingQueueSize: @incoming_queue.length,
+          },
+        ),
+      )
+    end
+
+    # Discovers all available test groups and examples in a given file taking into consideration the merged response of
+    # all add-ons
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def discover_tests(message)
+      document = @store.get(message.dig(:params, :textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      cached_response = document.cache_get("rubyLsp/discoverTests")
+      if cached_response != Document::EMPTY_CACHE
+        send_message(Result.new(id: message[:id], response: cached_response.map(&:to_hash)))
+        return
+      end
+
+      items = Requests::DiscoverTests.new(@global_state, document, Prism::Dispatcher.new).perform
+      document.cache_set("rubyLsp/discoverTests", items)
+
+      send_message(Result.new(id: message[:id], response: items.map(&:to_hash)))
+    end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -158,7 +158,8 @@ module RubyLsp
       # If there's a top level Gemfile, we want to evaluate from the composed bundle. We get the source from the top
       # level Gemfile, so if there isn't one we need to add a default source
       if @gemfile&.exist? && @lockfile&.exist?
-        parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
+        gemfile_path = @gemfile.relative_path_from(@custom_dir.realpath)
+        parts << "eval_gemfile(File.expand_path(\"#{gemfile_path}\", __dir__))"
       else
         parts.unshift('source "https://rubygems.org"')
       end
@@ -360,7 +361,7 @@ module RubyLsp
       # setting name `e` is `path` with a value of `vendor/bundle`, then it will return `"BUNDLE_PATH" =>
       # "vendor/bundle"`
       settings.all.to_h do |e|
-        key = Bundler::Settings.key_for(e)
+        key = settings.key_for(e)
         value = Array(settings[e]).join(":").tr(" ", ":")
 
         [key, value]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.9
+  version: 0.23.11
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-02-06 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -140,6 +140,7 @@ files:
 - lib/ruby_lsp/listeners/inlay_hints.rb
 - lib/ruby_lsp/listeners/semantic_highlighting.rb
 - lib/ruby_lsp/listeners/signature_help.rb
+- lib/ruby_lsp/listeners/test_style.rb
 - lib/ruby_lsp/load_sorbet.rb
 - lib/ruby_lsp/node_context.rb
 - lib/ruby_lsp/rbs_document.rb
@@ -150,6 +151,7 @@ files:
 - lib/ruby_lsp/requests/completion_resolve.rb
 - lib/ruby_lsp/requests/definition.rb
 - lib/ruby_lsp/requests/diagnostics.rb
+- lib/ruby_lsp/requests/discover_tests.rb
 - lib/ruby_lsp/requests/document_highlight.rb
 - lib/ruby_lsp/requests/document_link.rb
 - lib/ruby_lsp/requests/document_symbol.rb
@@ -178,6 +180,7 @@ files:
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
+- lib/ruby_lsp/requests/support/test_item.rb
 - lib/ruby_lsp/requests/type_hierarchy_supertypes.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb
@@ -186,6 +189,7 @@ files:
 - lib/ruby_lsp/response_builders/response_builder.rb
 - lib/ruby_lsp/response_builders/semantic_highlighting.rb
 - lib/ruby_lsp/response_builders/signature_help.rb
+- lib/ruby_lsp/response_builders/test_collection.rb
 - lib/ruby_lsp/ruby_document.rb
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/scripts/compose_bundle.rb