ruby-lsp 0.23.7 → 0.23.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b72d1b9ba142496f64035b6b1ad54d096c0a28ae52311612bd118bc49e2956
-  data.tar.gz: 525dc46dcfc71ee57da51955a4034ceace3bbdd1eca7942b542ab2cd32d42ad4
+  metadata.gz: 918079e906832b0289a053cd4bfe849422082c25bd0f4bdada25cab3a532005f
+  data.tar.gz: 7935b2bdc52a2bb83264376fb98f7ef8d3bfc3c5cb9dadd23642a1ebafbca013
 SHA512:
-  metadata.gz: '06690b76d284ca6abc05fc0e836af32a54c0a3cedea1fd53071648330a3b3b6e6d1a59ef205127f54a88e8cd3ca07c3840f25f1293e37737d705b2ea41719cb1'
-  data.tar.gz: bd6104ef180f122d0bb9d6d751213c43f0d19d0f203deb50e5d94583ff0aaf85559a040ca0371fc24506ff11a0d2742c14f1277226cc34d3a09d02730d46aed7
+  metadata.gz: 9fb084d322308bb2e69c2c0d5cfed2d275fe53f5df40aa2a49a848aab4c771858dfa1b5d5df913516c1f1c90ce5101b2f461865093f5e6787c79886cadc40bdb
+  data.tar.gz: 06206026d180e9d044edda0a83018ae31895cce3e6d91cb9ae4bdb3c365565a27881dd17ffd6d8861d8126441e327cb8fdf91c41e6003c1d84a4038c8b9003ea

data/VERSION

@@ -1 +1 @@
-0.23.7
+0.23.8

data/exe/ruby-lsp-launcher

@@ -51,7 +51,7 @@ end
 
 begin
   # Wait until the composed Bundle is finished
-  Process.wait(pid)
+  _, status = Process.wait2(pid)
 rescue Errno::ECHILD
   # In theory, the child process can finish before we even get to the wait call, but that is not an error
 end
@@ -105,7 +105,7 @@ end
 # flow, we are not booting the LSP yet, just checking if the bundle is valid before rebooting
 if reboot
   # Use the exit status to signal to the server if composing the bundle succeeded
-  exit(install_error || setup_error ? 1 : 0)
+  exit(install_error || setup_error ? 1 : status&.exitstatus || 0)
 end
 
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already

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

@@ -120,8 +120,16 @@ module RubyIndexer
       )]))
     end
     def first_unqualified_const(name)
+      # Look for an exact match first
       _name, entries = @entries.find do |const_name, _entries|
-        const_name.end_with?(name)
+        const_name == name || const_name.end_with?("::#{name}")
+      end
+
+      # If an exact match is not found, then try to find a constant that ends with the name
+      unless entries
+        _name, entries = @entries.find do |const_name, _entries|
+          const_name.end_with?(name)
+        end
       end
 
       T.cast(
@@ -593,7 +601,7 @@ module RubyIndexer
       entries = self[variable_name]&.grep(Entry::ClassVariable)
       return unless entries&.any?
 
-      ancestors = linearized_ancestors_of(owner_name)
+      ancestors = linearized_attached_ancestors(owner_name)
       return if ancestors.empty?
 
       entries.select { |e| ancestors.include?(e.owner&.name) }
@@ -601,12 +609,33 @@ module RubyIndexer
 
     # Returns a list of possible candidates for completion of instance variables for a given owner name. The name must
     # include the `@` prefix
-    sig { params(name: String, owner_name: String).returns(T::Array[Entry::InstanceVariable]) }
+    sig do
+      params(name: String, owner_name: String).returns(T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+    end
     def instance_variable_completion_candidates(name, owner_name)
-      entries = T.cast(prefix_search(name).flatten, T::Array[Entry::InstanceVariable])
+      entries = T.cast(prefix_search(name).flatten, T::Array[T.any(Entry::InstanceVariable, Entry::ClassVariable)])
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
+
       ancestors = linearized_ancestors_of(owner_name)
 
-      variables = entries.select { |e| ancestors.any?(e.owner&.name) }
+      instance_variables, class_variables = entries.partition { |e| e.is_a?(Entry::InstanceVariable) }
+      variables = instance_variables.select { |e| ancestors.any?(e.owner&.name) }
+
+      # Class variables are only owned by the attached class in our representation. If the owner is in a singleton
+      # context, we have to search for ancestors of the attached class
+      if class_variables.any?
+        name_parts = owner_name.split("::")
+
+        if name_parts.last&.start_with?("<Class:")
+          attached_name = T.must(name_parts[0..-2]).join("::")
+          attached_ancestors = linearized_ancestors_of(attached_name)
+          variables.concat(class_variables.select { |e| attached_ancestors.any?(e.owner&.name) })
+        else
+          variables.concat(class_variables.select { |e| ancestors.any?(e.owner&.name) })
+        end
+      end
+
       variables.uniq!(&:name)
       variables
     end
@@ -614,8 +643,10 @@ module RubyIndexer
     sig { params(name: String, owner_name: String).returns(T::Array[Entry::ClassVariable]) }
     def class_variable_completion_candidates(name, owner_name)
       entries = T.cast(prefix_search(name).flatten, T::Array[Entry::ClassVariable])
-      ancestors = linearized_ancestors_of(owner_name)
+      # Avoid wasting time linearizing ancestors if we didn't find anything
+      return entries if entries.empty?
 
+      ancestors = linearized_attached_ancestors(owner_name)
       variables = entries.select { |e| ancestors.any?(e.owner&.name) }
       variables.uniq!(&:name)
       variables
@@ -717,6 +748,20 @@ module RubyIndexer
 
     private
 
+    # Always returns the linearized ancestors for the attached class, regardless of whether `name` refers to a singleton
+    # or attached namespace
+    sig { params(name: String).returns(T::Array[String]) }
+    def linearized_attached_ancestors(name)
+      name_parts = name.split("::")
+
+      if name_parts.last&.start_with?("<Class:")
+        attached_name = T.must(name_parts[0..-2]).join("::")
+        linearized_ancestors_of(attached_name)
+      else
+        linearized_ancestors_of(name)
+      end
+    end
+
     # Runs the registered included hooks
     sig { params(fully_qualified_name: String, nesting: T::Array[String]).void }
     def run_included_hooks(fully_qualified_name, nesting)

data/lib/ruby_indexer/test/index_test.rb

@@ -1561,6 +1561,23 @@ module RubyIndexer
       assert_equal("Foo::Bar", entry.name)
     end
 
+    def test_first_unqualified_const_prefers_exact_matches
+      index(<<~RUBY)
+        module Foo
+          class ParseResultType
+          end
+        end
+
+        module Namespace
+          class Type
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.first_unqualified_const("Type")&.first)
+      assert_equal("Namespace::Type", entry.name)
+    end
+
     def test_completion_does_not_duplicate_overridden_methods
       index(<<~RUBY)
         class Foo
@@ -2092,5 +2109,57 @@ module RubyIndexer
       refute_nil(entry, "Expected indexer to be able to handle unsaved URIs")
       assert_equal("I added this comment!", entry.comments)
     end
+
+    def test_instance_variable_completion_returns_class_variables_too
+      index(<<~RUBY)
+        class Parent
+          @@abc = 123
+        end
+
+        class Child < Parent
+          @@adf = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      abc, adf = @index.instance_variable_completion_candidates("@", "Child::<Class:Child>")
+
+      refute_nil(abc)
+      refute_nil(adf)
+
+      assert_equal("@@abc", abc.name)
+      assert_equal("@@adf", adf.name)
+    end
+
+    def test_class_variable_completion_from_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+
+          def self.do
+          end
+        end
+      RUBY
+
+      candidates = @index.class_variable_completion_candidates("@@", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    end
+
+    def test_resolve_class_variable_in_singleton_context
+      index(<<~RUBY)
+        class Foo
+          @@hello = 123
+        end
+      RUBY
+
+      candidates = @index.resolve_class_variable("@@hello", "Foo::<Class:Foo>")
+      refute_empty(candidates)
+
+      assert_equal("@@hello", candidates.first&.name)
+    end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -22,6 +22,7 @@ require "prism/visitor"
 require "language_server-protocol"
 require "rbs"
 require "fileutils"
+require "open3"
 
 require "ruby-lsp"
 require "ruby_lsp/base_server"

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -170,7 +170,7 @@ module RubyLsp
 
       sig { params(line: Integer, character: Integer).void }
       def move_cursor_to(line, character)
-        return unless @client_name.start_with?("Visual Studio Code")
+        return unless /Visual Studio Code|Cursor/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,

data/lib/ruby_lsp/server.rb

@@ -1036,6 +1036,10 @@ module RubyLsp
       when Constant::FileChangeType::DELETED
         index.delete(uri)
       end
+    rescue Errno::ENOENT
+      # If a file is created and then delete immediately afterwards, we will process the created notification before we
+      # receive the deleted one, but the file no longer exists. This may happen when running a test suite that creates
+      # and deletes files automatically.
     end
 
     sig { params(uri: URI::Generic).void }
@@ -1286,25 +1290,40 @@ module RubyLsp
       addon.handle_window_show_message_response(result[:title])
     end
 
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    # NOTE: all servers methods are void because they can produce several messages for the client. The only reason this
+    # method returns the created thread is to that we can join it in tests and avoid flakiness. The implementation is
+    # not supposed to rely on the return of this method
+    sig { params(message: T::Hash[Symbol, T.untyped]).returns(T.nilable(Thread)) }
     def compose_bundle(message)
       already_composed_path = File.join(@global_state.workspace_path, ".ruby-lsp", "bundle_is_composed")
-      command = "#{Gem.ruby} #{File.expand_path("../../exe/ruby-lsp-launcher", __dir__)} #{@global_state.workspace_uri}"
       id = message[:id]
 
       begin
-        Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+        Bundler.with_original_env do
+          Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+        end
       rescue Bundler::LockfileError => e
         send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: e.message))
         return
+      rescue Bundler::GemfileNotFound, Errno::ENOENT
+        # We still compose the bundle if there's no Gemfile or if the lockfile got deleted
       end
 
       # We compose the bundle in a thread so that the LSP continues to work while we're checking for its validity. Once
       # we return the response back to the editor, then the restart is triggered
       Thread.new do
         send_log_message("Recomposing the bundle ahead of restart")
-        pid = Process.spawn(command)
-        _, status = Process.wait2(pid)
+
+        _stdout, stderr, status = Bundler.with_unbundled_env do
+          Open3.capture3(
+            Gem.ruby,
+            "-I",
+            File.dirname(T.must(__dir__)),
+            File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
+            @global_state.workspace_uri.to_s,
+            chdir: @global_state.workspace_path,
+          )
+        end
 
         if status&.exitstatus == 0
           # Create a signal for the restart that it can skip composing the bundle and launch directly
@@ -1313,7 +1332,9 @@ module RubyLsp
         else
           # This special error code makes the extension avoid restarting in case we already know that the composed
           # bundle is not valid
-          send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle"))
+          send_message(
+            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
+          )
         end
       end
     end

data/lib/ruby_lsp/setup_bundler.rb

@@ -241,8 +241,7 @@ module RubyLsp
 
       # If either the Gemfile or the lockfile have been modified during the process of setting up the bundle, retry
       # composing the bundle from scratch
-
-      if @gemfile && @lockfile
+      if @gemfile&.exist? && @lockfile&.exist?
         current_gemfile_hash = Digest::SHA256.hexdigest(@gemfile.read)
         current_lockfile_hash = Digest::SHA256.hexdigest(@lockfile.read)
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.7
+  version: 0.23.8
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2025-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol