ruby-lsp 0.26.1 → 0.26.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c80f549675508ffbb28d649de04506adabec01eac9aa4c6eee057ec848adf858
-  data.tar.gz: 71ea1a4d628444b98bc1173748f5aecf0d71bdc8d3dc80f33b2779c9c78d9de0
+  metadata.gz: 90c12f93d4750216ef84e046fe970f0ccc8edd7567943b9f4be02dc3828fd151
+  data.tar.gz: ef810d7d1599f9539474e87067c5972ef2aa3a6143452494e9d03857d64771e7
 SHA512:
-  metadata.gz: 7261bf15c095154ff36152492aa252cbd84b84f6e83eb458623c7bb9790a57957885a855c2ee10683b7035267177e323c013988befc02e96f3fdf0274d2312ca
-  data.tar.gz: 74bcea4844e876230713400776bf7def1db44492bcf913526195b5d01919efd24ac69b517594ce2499e332184bf7ef4881e17e7694574bf4d35afabeda25b8c4
+  metadata.gz: 4a6ff236ecaabfd5e927a6f57f47d97ad6822dc647ce3531c57565adfc05fd592167decbabfa2ac3420d8294f193188103c7aa3a468b5f92dca7b18a92bb1b87
+  data.tar.gz: e34f78b58b73536faecf0bafb0f7a620bbbc3122c8fb8d1b526112b000055b78fe6d153ff0bf1bbd2300aaaffb3f5a6327fd7ef4248332b39ebb5a7c13fe94d5

data/VERSION

@@ -1 +1 @@
-0.26.1
+0.26.3

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

@@ -195,12 +195,13 @@ module RubyIndexer
     end
 
     # Fuzzy searches index entries based on Jaro-Winkler similarity. If no query is provided, all entries are returned
-    #: (String? query) -> Array[Entry]
-    def fuzzy_search(query)
+    #: (String? query) ?{ (Entry) -> bool? } -> Array[Entry]
+    def fuzzy_search(query, &condition)
       unless query
         entries = @entries.filter_map do |_name, entries|
           next if entries.first.is_a?(Entry::SingletonClass)
 
+          entries = entries.select(&condition) if condition
           entries
         end
 
@@ -212,6 +213,9 @@ module RubyIndexer
       results = @entries.filter_map do |name, entries|
         next if entries.first.is_a?(Entry::SingletonClass)
 
+        entries = entries.select(&condition) if condition
+        next if entries.empty?
+
         similarity = DidYouMean::JaroWinkler.distance(name.gsub("::", "").downcase, normalized_query)
         [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
       end
@@ -424,7 +428,10 @@ module RubyIndexer
       (parts.length - 1).downto(0) do |i|
         current_name = parts[0..i] #: as !nil
           .join("::")
-        entry = @entries[current_name]&.first
+
+        entry = unless seen_names.include?(current_name)
+          @entries[current_name]&.first
+        end
 
         case entry
         when Entry::ConstantAlias
@@ -904,6 +911,9 @@ module RubyIndexer
       target = resolve(entry.target, entry.nesting, seen_names)
       return entry unless target
 
+      # Self referential alias can be unresolved we should bail out from resolving
+      return entry if target.first == entry
+
       target_name = target.first #: as !nil
         .name
       resolved_alias = Entry::ConstantAlias.new(target_name, entry)
@@ -1023,11 +1033,19 @@ module RubyIndexer
       name_parts.join("::")
     end
 
+    # Tries to return direct entry from index then non seen canonicalized alias or nil
     #: (String full_name, Array[String] seen_names) -> Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias]?
     def direct_or_aliased_constant(full_name, seen_names)
-      entries = @entries[full_name] || @entries[follow_aliased_namespace(full_name)]
+      if (entries = @entries[full_name])
+        return entries.map do |e|
+          e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e
+        end #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias])?
+      end
+
+      aliased = follow_aliased_namespace(full_name, seen_names)
+      return if full_name == aliased || seen_names.include?(aliased)
 
-      entries&.map do |e|
+      @entries[aliased]&.map do |e|
         e.is_a?(Entry::UnresolvedConstantAlias) ? resolve_alias(e, seen_names) : e
       end #: as Array[Entry::Constant | Entry::ConstantAlias | Entry::Namespace | Entry::UnresolvedConstantAlias])?
     end

data/lib/ruby_indexer/test/index_test.rb

@@ -1152,6 +1152,46 @@ module RubyIndexer
       assert_equal(2, foo_entry.location.start_line)
     end
 
+    def test_resolving_self_referential_constant_alias
+      index(<<~RUBY)
+        module A
+          module B
+            class C
+            end
+          end
+        end
+
+        module A
+          module D
+            B = B::C
+          end
+        end
+      RUBY
+
+      entry = @index.resolve("A::D::B", [])&.first #: as Entry::ConstantAlias
+
+      assert_kind_of(RubyIndexer::Entry::ConstantAlias, entry)
+      assert_equal(10, entry.location.start_line)
+      assert_equal("A::B::C", entry.target)
+    end
+
+    def test_resolving_non_existing_self_referential_constant_alias
+      index(<<~RUBY)
+        module Foo
+          SomeClass = ::SomeClass
+          UNRESOLVED = SomeClass::CONSTANT
+        end
+      RUBY
+
+      entry = @index.resolve("Foo::UNRESOLVED", [])&.first #: as Entry::UnresolvedConstantAlias
+      assert_kind_of(Entry::UnresolvedConstantAlias, entry)
+      assert_equal(3, entry.location.start_line)
+      assert_equal("SomeClass::CONSTANT", entry.target)
+
+      entry = @index.resolve("SomeClass::CONSTANT", ["Foo"])
+      refute(entry)
+    end
+
     def test_resolving_qualified_references
       index(<<~RUBY)
         module Namespace

data/lib/ruby_lsp/base_server.rb

@@ -83,7 +83,7 @@ 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", "rubyLsp/diagnoseState"
+        when "initialize", "initialized", "rubyLsp/diagnoseState", "$/cancelRequest"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -103,7 +103,7 @@ module RubyLsp
     # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
     #: -> untyped
     def pop_response
-      @outgoing_queue.pop
+      @outgoing_queue.pop(timeout: 20) || raise("No message received from server")
     end
 
     # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
@@ -154,20 +154,29 @@ module RubyLsp
     def new_worker
       Thread.new do
         while (message = @incoming_queue.pop)
-          id = message[:id]
-
-          # Check if the request was cancelled before trying to process it
-          @global_state.synchronize do
-            if id && @cancelled_requests.include?(id)
-              send_message(Result.new(id: id, response: nil))
-              @cancelled_requests.delete(id)
-              next
-            end
-          end
+          handle_incoming_message(message)
+        end
+      end
+    end
 
-          process_message(message)
+    #: (Hash[Symbol, untyped]) -> void
+    def handle_incoming_message(message)
+      id = message[:id]
+
+      # Check if the request was cancelled before trying to process it
+      @global_state.synchronize do
+        if id && @cancelled_requests.include?(id)
+          send_message(Error.new(
+            id: id,
+            code: Constant::ErrorCodes::REQUEST_CANCELLED,
+            message: "Request #{id} was cancelled",
+          ))
+          @cancelled_requests.delete(id)
+          return
         end
       end
+
+      process_message(message)
     end
 
     #: ((Result | Error | Notification | Request) message) -> void

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -92,7 +92,8 @@ module RubyLsp
             Prism::RequiredParameterNode, Prism::RestParameterNode
             [target, node_value(target)]
           when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
-            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
+            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode, Prism::BlockNode,
+            Prism::LambdaNode, Prism::BeginNode
             [target, nil]
           end
 
@@ -157,6 +158,9 @@ module RubyLsp
             :on_for_node_enter,
             :on_if_node_enter,
             :on_unless_node_enter,
+            :on_block_node_enter,
+            :on_lambda_node_enter,
+            :on_begin_node_enter,
           )
         end
       end
@@ -551,6 +555,27 @@ module RubyLsp
         add_matching_end_highlights(node.keyword_loc, node.end_keyword_loc)
       end
 
+      #: (Prism::BlockNode node) -> void
+      def on_block_node_enter(node)
+        return unless @target.is_a?(Prism::BlockNode)
+
+        add_matching_end_highlights(node.opening_loc, node.closing_loc)
+      end
+
+      #: (Prism::LambdaNode node) -> void
+      def on_lambda_node_enter(node)
+        return unless @target.is_a?(Prism::LambdaNode)
+
+        add_matching_end_highlights(node.opening_loc, node.closing_loc)
+      end
+
+      #: (Prism::BeginNode node) -> void
+      def on_begin_node_enter(node)
+        return unless @target.is_a?(Prism::BeginNode)
+
+        add_matching_end_highlights(node.begin_keyword_loc, node.end_keyword_loc)
+      end
+
       private
 
       #: (Prism::Node node, Array[singleton(Prism::Node)] classes) -> bool?

data/lib/ruby_lsp/listeners/document_link.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/source_uri"
+require "ruby_lsp/requests/support/package_url"
 
 module RubyLsp
   module Listeners
@@ -102,19 +103,58 @@ module RubyLsp
         comment = @lines_to_comments[node.location.start_line - 1]
         return unless comment
 
-        match = comment.location.slice.match(%r{source://.*#\d+$})
+        match = comment.location.slice.match(%r{(source://.*#\d+|pkg:gem/.*#.*)$})
         return unless match
 
-        uri =  begin
-          URI(
-            match[0], #: as !nil
-          )
+        uri_string = match[0] #: as !nil
+
+        file_path, line_number = if uri_string.start_with?("pkg:gem/")
+          parse_package_url(uri_string)
+        else
+          parse_source_uri(uri_string)
+        end
+
+        return unless file_path
+
+        @response_builder << Interface::DocumentLink.new(
+          range: range_from_location(comment.location),
+          target: "file://#{file_path}##{line_number}",
+          tooltip: "Jump to #{file_path}##{line_number}",
+        )
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_package_url(uri_string)
+        purl = PackageURL.parse(uri_string) #: as PackageURL?
+        return unless purl
+
+        gem_version = resolve_version(purl.version, purl.name)
+        return if gem_version.nil?
+
+        path, line_number = purl.subpath.split(":", 2)
+        return unless path
+
+        gem_name = purl.name
+        return unless gem_name
+
+        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
+        return if file_path.nil?
+
+        [file_path, line_number]
+      rescue PackageURL::InvalidPackageURL
+        nil
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_source_uri(uri_string)
+        uri = begin
+          URI(uri_string)
         rescue URI::Error
           nil
         end #: as URI::Source?
         return unless uri
 
-        gem_version = resolve_version(uri)
+        gem_version = resolve_version(uri.gem_version, uri.gem_name)
         return if gem_version.nil?
 
         path = uri.path
@@ -126,28 +166,20 @@ module RubyLsp
         file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
         return if file_path.nil?
 
-        @response_builder << Interface::DocumentLink.new(
-          range: range_from_location(comment.location),
-          target: "file://#{file_path}##{uri.line_number}",
-          tooltip: "Jump to #{file_path}##{uri.line_number}",
-        )
+        [file_path, uri.line_number || "0"]
       end
 
       # Try to figure out the gem version for a source:// link. The order of precedence is:
       # 1. The version in the URI
       # 2. The version in the RBI file name
       # 3. The version from the gemspec
-      #: (URI::Source uri) -> String?
-      def resolve_version(uri)
-        version = uri.gem_version
+      #: (String? version, String? gem_name) -> String?
+      def resolve_version(version, gem_name)
         return version unless version.nil? || version.empty?
 
         return @gem_version unless @gem_version.nil? || @gem_version.empty?
 
-        gem_name = uri.gem_name
-        return unless gem_name
-
-        GEM_TO_VERSION_MAP[gem_name]
+        GEM_TO_VERSION_MAP[gem_name.to_s]
       end
     end
   end

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -58,13 +58,11 @@ module RubyLsp
 
       #: (Prism::CallNode) -> void
       def on_call_node_enter(node) # rubocop:disable RubyLsp/UseRegisterWithHandlerMethod
-        return unless in_spec_context?
-
         case node.name
         when :describe
           handle_describe(node)
         when :it, :specify
-          handle_example(node)
+          handle_example(node) if in_spec_context?
         end
       end
 
@@ -117,10 +115,7 @@ module RubyLsp
 
       #: (Prism::CallNode) -> void
       def handle_example(node)
-        # Minitest formats the descriptions into test method names by using the count of examples with the description
-        # We are not guaranteed to discover examples in the exact order using static analysis, so we use the line number
-        # instead. Note that anonymous examples mixed with meta-programming will not be handled correctly
-        description = extract_description(node) || "anonymous"
+        description = extract_it_description(node)
         line = node.location.start_line - 1
         parent = latest_group
         return unless parent.is_a?(Requests::Support::TestItem)
@@ -141,16 +136,37 @@ module RubyLsp
 
       #: (Prism::CallNode) -> String?
       def extract_description(node)
+        arguments = node.arguments&.arguments
+        return unless arguments
+
+        parts = arguments.map { |arg| extract_argument_content(arg) }
+        return if parts.empty?
+
+        parts.join("::")
+      end
+
+      #: (Prism::CallNode) -> String
+      def extract_it_description(node)
+        # Minitest formats the descriptions into test method names by using the count of examples with the description
+        # We are not guaranteed to discover examples in the exact order using static analysis, so we use the line number
+        # instead. Note that anonymous examples mixed with meta-programming will not be handled correctly
         first_argument = node.arguments&.arguments&.first
-        return unless first_argument
+        return "anonymous" unless first_argument
+
+        extract_argument_content(first_argument) || "anonymous"
+      end
 
-        case first_argument
+      #: (Prism::Node) -> String?
+      def extract_argument_content(arg)
+        case arg
         when Prism::StringNode
-          first_argument.content
+          arg.content
+        when Prism::SymbolNode
+          arg.value
         when Prism::ConstantReadNode, Prism::ConstantPathNode
-          constant_name(first_argument)
+          constant_name(arg)
         else
-          first_argument.slice
+          arg.slice
         end
       end
 
@@ -190,12 +206,13 @@ module RubyLsp
         end
 
         # Specs only using describes
-        first_group = @spec_group_id_stack.find { |i| i.is_a?(DescribeGroup) }
-        return unless first_group
+        first_group_index = @spec_group_id_stack.index { |i| i.is_a?(DescribeGroup) }
+        return unless first_group_index
 
+        first_group = @spec_group_id_stack[first_group_index] #: as !nil
         item = @response_builder[first_group.id] #: as !nil
 
-        @spec_group_id_stack[1..] #: as !nil
+        @spec_group_id_stack[first_group_index + 1..] #: as !nil
           .each do |group|
           next unless group.is_a?(DescribeGroup)
 

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -61,11 +61,26 @@ module RubyLsp
 
       #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]
       def calc_attached_ancestors(node, fully_qualified_name)
-        @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
+        superclass = node.superclass
+
+        begin
+          ancestors = @index.linearized_ancestors_of(fully_qualified_name)
+          # If the project has no bundle and a test class inherits from `Minitest::Test`, the linearized ancestors will
+          # not include the parent class because we never indexed it in the first place. Here we add the superclass
+          # directly, so that we can support running tests in projects without a bundle
+          return ancestors if ancestors.length > 1
+
+          # If all we found is the class itself, then manually include the parent class
+          if ancestors.first == fully_qualified_name && superclass
+            return [*ancestors, superclass.slice]
+          end
+
+          ancestors
+        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
+          [superclass&.slice].compact
+        end
       end
 
       #: (Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode node) -> String

data/lib/ruby_lsp/listeners/test_style.rb

@@ -33,13 +33,15 @@ module RubyLsp
 
             if tags.include?("test_dir")
               if children.empty?
-                full_files.concat(Dir.glob(
-                  "#{path}/**/{*_test,test_*,*_spec}.rb",
-                  File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
-                ))
+                full_files.concat(
+                  Dir.glob(
+                    "#{path}/**/{*_test,test_*,*_spec}.rb",
+                    File::Constants::FNM_EXTGLOB | File::Constants::FNM_PATHNAME,
+                  ).map! { |p| Shellwords.escape(p) },
+                )
               end
             elsif tags.include?("test_file")
-              full_files << path if children.empty?
+              full_files << Shellwords.escape(path) if children.empty?
             elsif tags.include?("test_group")
               # If all of the children of the current test group are other groups, then there's no need to add it to the
               # aggregated examples
@@ -114,7 +116,7 @@ module RubyLsp
           end
 
           load_path = spec?(file_path) ? "-Ispec" : "-Itest"
-          "#{COMMAND} #{load_path} #{file_path} --name \"/#{regex}/\""
+          "#{COMMAND} #{load_path} #{Shellwords.escape(file_path)} --name \"/#{regex}/\""
         end
 
         #: (String, Hash[String, Hash[Symbol, untyped]]) -> Array[String]
@@ -125,7 +127,7 @@ module RubyLsp
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",
             )
-            command = +"#{COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}\\$/\""
+            command = +"#{COMMAND} -Itest #{Shellwords.escape(file_path)} --testcase \"/^#{group_regex}\\$/\""
 
             unless examples.empty?
               command << if examples.length == 1
@@ -145,7 +147,7 @@ module RubyLsp
       MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
       TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
       BASE_COMMAND = begin
-        Bundler.with_original_env { Bundler.default_lockfile }
+        Bundler.with_unbundled_env { Bundler.default_lockfile }
         "bundle exec ruby"
       rescue Bundler::GemfileNotFound
         "ruby"

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -35,24 +35,78 @@ module RubyLsp
 
       #: -> Array[String]
       def find_relevant_paths
-        candidate_paths = Dir.glob(File.join("**", relevant_filename_pattern))
+        patterns = relevant_filename_patterns
+
+        candidate_paths = patterns.flat_map do |pattern|
+          Dir.glob(File.join(search_root, "**", pattern))
+        end
+
         return [] if candidate_paths.empty?
 
-        find_most_similar_with_jaccard(candidate_paths).map { File.join(@workspace_path, _1) }
+        find_most_similar_with_jaccard(candidate_paths).map { |path| File.expand_path(path, @workspace_path) }
       end
 
+      # Determine the search roots based on the closest test directories.
+      # This scopes the search to reduce the number of files that need to be checked.
       #: -> String
-      def relevant_filename_pattern
-        input_basename = File.basename(@path, File.extname(@path))
+      def search_root
+        current_path = File.join(".", @path)
+        current_dir = File.dirname(current_path)
+        while current_dir != "."
+          dir_basename = File.basename(current_dir)
+
+          # If current directory is a test directory, return its parent as search root
+          if TEST_KEYWORDS.include?(dir_basename)
+            return File.dirname(current_dir)
+          end
 
-        relevant_basename_pattern =
-          if input_basename.match?(TEST_PATTERN)
-            input_basename.gsub(TEST_PATTERN, "")
-          else
-            "{{#{TEST_PREFIX_GLOB}}#{input_basename},#{input_basename}{#{TEST_SUFFIX_GLOB}}}"
+          # Search the test directories by walking up the directory tree
+          begin
+            contains_test_dir = Dir
+              .entries(current_dir)
+              .filter { |entry| TEST_KEYWORDS.include?(entry) }
+              .any? { |entry| File.directory?(File.join(current_dir, entry)) }
+
+            return current_dir if contains_test_dir
+          rescue Errno::EACCES, Errno::ENOENT
+            # Skip directories we can't read
           end
 
-        "#{relevant_basename_pattern}#{File.extname(@path)}"
+          # Move up one level
+          parent_dir = File.dirname(current_dir)
+          current_dir = parent_dir
+        end
+
+        "."
+      end
+
+      #: -> Array[String]
+      def relevant_filename_patterns
+        extension = File.extname(@path)
+        input_basename = File.basename(@path, extension)
+
+        if input_basename.match?(TEST_PATTERN)
+          # Test file -> find implementation
+          base = input_basename.gsub(TEST_PATTERN, "")
+          parent_dir = File.basename(File.dirname(@path))
+
+          # If test file is in a directory matching the implementation name
+          # (e.g., go_to_relevant_file/test_go_to_relevant_file_a.rb)
+          # return patterns for both the base file name and the parent directory name
+          if base.include?(parent_dir) && base != parent_dir
+            ["#{base}#{extension}", "#{parent_dir}#{extension}"]
+          else
+            ["#{base}#{extension}"]
+          end
+        else
+          # Implementation file -> find tests (including in matching directory)
+          [
+            "{#{TEST_PREFIX_GLOB}}#{input_basename}#{extension}",
+            "#{input_basename}{#{TEST_SUFFIX_GLOB}}#{extension}",
+            "#{input_basename}/{#{TEST_PREFIX_GLOB}}*#{extension}",
+            "#{input_basename}/*{#{TEST_SUFFIX_GLOB}}#{extension}",
+          ]
+        end
       end
 
       # Using the Jaccard algorithm to determine the similarity between the

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

@@ -140,21 +140,25 @@ module RubyLsp
           end
         end
 
-        #: (RubyIndexer::Entry entry) -> Integer?
+        #: (RubyIndexer::Entry entry) -> Integer
         def kind_for_entry(entry)
           case entry
           when RubyIndexer::Entry::Class
             Constant::SymbolKind::CLASS
           when RubyIndexer::Entry::Module
             Constant::SymbolKind::NAMESPACE
-          when RubyIndexer::Entry::Constant
+          when RubyIndexer::Entry::Constant, RubyIndexer::Entry::UnresolvedConstantAlias, RubyIndexer::Entry::ConstantAlias
             Constant::SymbolKind::CONSTANT
-          when RubyIndexer::Entry::Method
+          when RubyIndexer::Entry::Method, RubyIndexer::Entry::UnresolvedMethodAlias, RubyIndexer::Entry::MethodAlias
             entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
           when RubyIndexer::Entry::Accessor
             Constant::SymbolKind::PROPERTY
-          when RubyIndexer::Entry::InstanceVariable
+          when RubyIndexer::Entry::InstanceVariable, RubyIndexer::Entry::ClassVariable
             Constant::SymbolKind::FIELD
+          when RubyIndexer::Entry::GlobalVariable
+            Constant::SymbolKind::VARIABLE
+          else
+            Constant::SymbolKind::NULL
           end
         end
       end

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

@@ -0,0 +1,414 @@
+# typed: false
+# frozen_string_literal: true
+
+# This is a copy of the implementation from the `package_url` gem with the
+# following license. Original source can be found at:
+# https://github.com/package-url/packageurl-ruby/blob/main/lib/package_url.rb
+
+# MIT License
+#
+# Copyright (c) 2021 package-url
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require "uri"
+
+# A package URL, or _purl_, is a URL string used to
+# identify and locate a software package in a mostly universal and uniform way
+# across programing languages, package managers, packaging conventions, tools,
+# APIs and databases.
+#
+# A purl is a URL composed of seven components:
+#
+# ```
+# scheme:type/namespace/name@version?qualifiers#subpath
+# ```
+#
+# For example,
+# the package URL for this Ruby package at version 0.1.0 is
+# `pkg:ruby/mattt/packageurl-ruby@0.1.0`.
+module RubyLsp
+  class PackageURL
+    # Raised when attempting to parse an invalid package URL string.
+    # @see #parse
+    class InvalidPackageURL < ArgumentError; end
+
+    # The URL scheme, which has a constant value of `"pkg"`.
+    def scheme
+      "pkg"
+    end
+
+    # The package type or protocol, such as `"gem"`, `"npm"`, and `"github"`.
+    attr_reader :type
+
+    # A name prefix, specific to the type of package.
+    # For example, an npm scope, a Docker image owner, or a GitHub user.
+    attr_reader :namespace
+
+    # The name of the package.
+    attr_reader :name
+
+    # The version of the package.
+    attr_reader :version
+
+    # Extra qualifying data for a package, specific to the type of package.
+    # For example, the operating system or architecture.
+    attr_reader :qualifiers
+
+    # An extra subpath within a package, relative to the package root.
+    attr_reader :subpath
+
+    # Constructs a package URL from its components
+    # @param type [String] The package type or protocol.
+    # @param namespace [String] A name prefix, specific to the type of package.
+    # @param name [String] The name of the package.
+    # @param version [String] The version of the package.
+    # @param qualifiers [Hash] Extra qualifying data for a package, specific to the type of package.
+    # @param subpath [String] An extra subpath within a package, relative to the package root.
+    def initialize(type:, name:, namespace: nil, version: nil, qualifiers: nil, subpath: nil)
+      raise ArgumentError, "type is required" if type.nil? || type.empty?
+      raise ArgumentError, "name is required" if name.nil? || name.empty?
+
+      @type = type.downcase
+      @namespace = namespace
+      @name = name
+      @version = version
+      @qualifiers = qualifiers
+      @subpath = subpath
+    end
+
+    # Creates a new PackageURL from a string.
+    # @param [String] string The package URL string.
+    # @raise [InvalidPackageURL] If the string is not a valid package URL.
+    # @return [PackageURL]
+    def self.parse(string)
+      components = {
+        type: nil,
+        namespace: nil,
+        name: nil,
+        version: nil,
+        qualifiers: nil,
+        subpath: nil,
+      }
+
+      # Split the purl string once from right on '#'
+      # - The left side is the remainder
+      # - Strip the right side from leading and trailing '/'
+      # - Split this on '/'
+      # - Discard any empty string segment from that split
+      # - Discard any '.' or '..' segment from that split
+      # - Percent-decode each segment
+      # - UTF-8-decode each segment if needed in your programming language
+      # - Join segments back with a '/'
+      # - This is the subpath
+      case string.rpartition("#")
+      in String => remainder, separator, String => subpath unless separator.empty?
+        subpath_components = []
+        subpath.split("/").each do |segment|
+          next if segment.empty? || segment == "." || segment == ".."
+
+          subpath_components << URI.decode_www_form_component(segment)
+        end
+
+        components[:subpath] = subpath_components.compact.join("/")
+
+        string = remainder
+      else
+        components[:subpath] = nil
+      end
+
+      # Split the remainder once from right on '?'
+      # - The left side is the remainder
+      # - The right side is the qualifiers string
+      # - Split the qualifiers on '&'. Each part is a key=value pair
+      # - For each pair, split the key=value once from left on '=':
+      # - The key is the lowercase left side
+      # - The value is the percent-decoded right side
+      # - UTF-8-decode the value if needed in your programming language
+      # - Discard any key/value pairs where the value is empty
+      # - If the key is checksums,
+      #   split the value on ',' to create a list of checksums
+      # - This list of key/value is the qualifiers object
+      case string.rpartition("?")
+      in String => remainder, separator, String => qualifiers unless separator.empty?
+        components[:qualifiers] = {}
+
+        qualifiers.split("&").each do |pair|
+          case pair.partition("=")
+          in String => key, separator, String => value unless separator.empty?
+            key = key.downcase
+            value = URI.decode_www_form_component(value)
+            next if value.empty?
+
+            components[:qualifiers][key] = case key
+            when "checksums"
+              value.split(",")
+            else
+              value
+            end
+          else
+            next
+          end
+        end
+
+        string = remainder
+      else
+        components[:qualifiers] = nil
+      end
+
+      # Split the remainder once from left on ':'
+      # - The left side lowercased is the scheme
+      # - The right side is the remainder
+      case string.partition(":")
+      in "pkg", separator, String => remainder unless separator.empty?
+        string = remainder
+      else
+        raise InvalidPackageURL, 'invalid or missing "pkg:" URL scheme'
+      end
+
+      # Strip the remainder from leading and trailing '/'
+      # Use gsub to remove ALL leading slashes instead of just one
+      string = string.gsub(%r{^/+}, "").delete_suffix("/")
+      # - Split this once from left on '/'
+      # - The left side lowercased is the type
+      # - The right side is the remainder
+      case string.partition("/")
+      in String => type, separator, remainder unless separator.empty?
+        components[:type] = type
+
+        string = remainder
+      else
+        raise InvalidPackageURL, "invalid or missing package type"
+      end
+
+      # Split the remainder once from right on '@'
+      # - The left side is the remainder
+      # - Percent-decode the right side. This is the version.
+      # - UTF-8-decode the version if needed in your programming language
+      # - This is the version
+      case string.rpartition("@")
+      in String => remainder, separator, String => version unless separator.empty?
+        components[:version] = URI.decode_www_form_component(version)
+
+        string = remainder
+      else
+        components[:version] = nil
+      end
+
+      # Split the remainder once from right on '/'
+      # - The left side is the remainder
+      # - Percent-decode the right side. This is the name
+      # - UTF-8-decode this name if needed in your programming language
+      # - Apply type-specific normalization to the name if needed
+      # - This is the name
+      case string.rpartition("/")
+      in String => remainder, separator, String => name unless separator.empty?
+        components[:name] = URI.decode_www_form_component(name)
+
+        # Split the remainder on '/'
+        # - Discard any empty segment from that split
+        # - Percent-decode each segment
+        # - UTF-8-decode the each segment if needed in your programming language
+        # - Apply type-specific normalization to each segment if needed
+        # - Join segments back with a '/'
+        # - This is the namespace
+        components[:namespace] = remainder.split("/").map { |s| URI.decode_www_form_component(s) }.compact.join("/")
+      in _, _, String => name
+        components[:name] = URI.decode_www_form_component(name)
+        components[:namespace] = nil
+      end
+
+      # Ensure type and name are not nil before creating the PackageURL instance
+      raise InvalidPackageURL, "missing package type" if components[:type].nil?
+      raise InvalidPackageURL, "missing package name" if components[:name].nil?
+
+      # Create a new PackageURL with validated components
+      type = components[:type] || ""  # This ensures type is never nil
+      name = components[:name] || ""  # This ensures name is never nil
+
+      new(
+        type: type,
+        name: name,
+        namespace: components[:namespace],
+        version: components[:version],
+        qualifiers: components[:qualifiers],
+        subpath: components[:subpath],
+      )
+    end
+
+    # Returns a hash containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def to_h
+      {
+        scheme: scheme,
+        type: @type,
+        namespace: @namespace,
+        name: @name,
+        version: @version,
+        qualifiers: @qualifiers,
+        subpath: @subpath,
+      }
+    end
+
+    # Returns a string representation of the package URL.
+    # Package URL representations are created according to the instructions from
+    # https://github.com/package-url/purl-spec/blob/0b1559f76b79829e789c4f20e6d832c7314762c5/PURL-SPECIFICATION.rst#how-to-build-purl-string-from-its-components.
+    def to_s
+      # Start a purl string with the "pkg:" scheme as a lowercase ASCII string
+      purl = "pkg:"
+
+      # Append the type string to the purl as a lowercase ASCII string
+      # Append '/' to the purl
+
+      purl += @type
+      purl += "/"
+
+      # If the namespace is not empty:
+      # - Strip the namespace from leading and trailing '/'
+      # - Split on '/' as segments
+      # - Apply type-specific normalization to each segment if needed
+      # - UTF-8-encode each segment if needed in your programming language
+      # - Percent-encode each segment
+      # - Join the segments with '/'
+      # - Append this to the purl
+      # - Append '/' to the purl
+      # - Strip the name from leading and trailing '/'
+      # - Apply type-specific normalization to the name if needed
+      # - UTF-8-encode the name if needed in your programming language
+      # - Append the percent-encoded name to the purl
+      #
+      # If the namespace is empty:
+      # - Apply type-specific normalization to the name if needed
+      # - UTF-8-encode the name if needed in your programming language
+      # - Append the percent-encoded name to the purl
+      case @namespace
+      in String => namespace unless namespace.empty?
+        segments = []
+        @namespace.delete_prefix("/").delete_suffix("/").split("/").each do |segment|
+          next if segment.empty?
+
+          segments << URI.encode_www_form_component(segment)
+        end
+        purl += segments.join("/")
+
+        purl += "/"
+        purl += URI.encode_www_form_component(@name.delete_prefix("/").delete_suffix("/"))
+      else
+        purl += URI.encode_www_form_component(@name)
+      end
+
+      # If the version is not empty:
+      # - Append '@' to the purl
+      # - UTF-8-encode the version if needed in your programming language
+      # - Append the percent-encoded version to the purl
+      case @version
+      in String => version unless version.empty?
+        purl += "@"
+        purl += URI.encode_www_form_component(@version)
+      else
+        nil
+      end
+
+      # If the qualifiers are not empty and not composed only of key/value pairs
+      # where the value is empty:
+      # - Append '?' to the purl
+      # - Build a list from all key/value pair:
+      # - discard any pair where the value is empty.
+      # - UTF-8-encode each value if needed in your programming language
+      # - If the key is checksums and this is a list of checksums
+      #   join this list with a ',' to create this qualifier value
+      # - create a string by joining the lowercased key,
+      #   the equal '=' sign and the percent-encoded value to create a qualifier
+      # - sort this list of qualifier strings lexicographically
+      # - join this list of qualifier strings with a '&' ampersand
+      # - Append this string to the purl
+      case @qualifiers
+      in Hash => qualifiers unless qualifiers.empty?
+        list = []
+        qualifiers.each do |key, value|
+          next if value.empty?
+
+          list << case [key, value]
+          in "checksums", Array => checksums
+            "#{key.downcase}=#{checksums.join(",")}"
+          else
+            "#{key.downcase}=#{URI.encode_www_form_component(value)}"
+          end
+        end
+
+        unless list.empty?
+          purl += "?"
+          purl += list.sort.join("&")
+        end
+      else
+        nil
+      end
+
+      # If the subpath is not empty and not composed only of
+      # empty, '.' and '..' segments:
+      # - Append '#' to the purl
+      # - Strip the subpath from leading and trailing '/'
+      # - Split this on '/' as segments
+      # - Discard empty, '.' and '..' segments
+      # - Percent-encode each segment
+      # - UTF-8-encode each segment if needed in your programming language
+      # - Join the segments with '/'
+      # - Append this to the purl
+      case @subpath
+      in String => subpath unless subpath.empty?
+        segments = []
+        subpath.delete_prefix("/").delete_suffix("/").split("/").each do |segment|
+          next if segment.empty? || segment == "." || segment == ".."
+
+          # Custom encoding for URL fragment segments:
+          # 1. Explicitly encode % as %25 to prevent double-encoding issues
+          # 2. Percent-encode special characters according to URL fragment rules
+          # 3. This ensures proper round-trip encoding/decoding with the parse method
+          segments << segment.gsub(/%|[^A-Za-z0-9\-\._~]/) do |m|
+            m == "%" ? "%25" : format("%%%02X", m.ord)
+          end
+        end
+
+        unless segments.empty?
+          purl += "#"
+          purl += segments.join("/")
+        end
+      else
+        nil
+      end
+
+      purl
+    end
+
+    # Returns an array containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def deconstruct
+      [scheme, @type, @namespace, @name, @version, @qualifiers, @subpath]
+    end
+
+    # Returns a hash containing the
+    # scheme, type, namespace, name, version, qualifiers, and subpath components
+    # of the package URL.
+    def deconstruct_keys(_keys)
+      to_h
+    end
+  end
+end

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

@@ -61,6 +61,14 @@ module RubyLsp
           "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
         ] #: Array[String]
 
+        # Functionality was introduced in 1.75.0 but had issues with autocorrect
+        REUSE_PRISM_RESULT = begin
+          gem("rubocop", ">= 1.80.1")
+          true
+        rescue LoadError
+          false
+        end #: bool
+
         #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
@@ -81,7 +89,7 @@ module RubyLsp
           @offenses = [] #: Array[::RuboCop::Cop::Offense]
           @errors = [] #: Array[String]
           @warnings = [] #: Array[String]
-          # @prism_result = nil #: Prism::ParseLexResult?
+          @prism_result = nil #: Prism::ParseLexResult?
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
@@ -101,11 +109,7 @@ module RubyLsp
           @warnings = []
           @offenses = []
           @options[:stdin] = contents
-
-          # Setting the Prism result before running the RuboCop runner makes it reuse the existing AST and avoids
-          # double-parsing. Unfortunately, this leads to a bunch of cops failing to execute properly under LSP mode.
-          # Uncomment this once reusing the Prism result is more stable
-          # @prism_result = prism_result
+          @prism_result = prism_result if REUSE_PRISM_RESULT
 
           super([path])
 

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -20,17 +20,7 @@ module RubyLsp
       # @override
       #: -> Array[Interface::WorkspaceSymbol]
       def perform
-        @index.fuzzy_search(@query).filter_map do |entry|
-          uri = entry.uri
-          file_path = uri.full_path
-
-          # We only show symbols declared in the workspace
-          in_dependencies = file_path && !not_in_dependencies?(file_path)
-          next if in_dependencies
-
-          # We should never show private symbols when searching the entire workspace
-          next if entry.private?
-
+        fuzzy_search.filter_map do |entry|
           kind = kind_for_entry(entry)
           loc = entry.location
 
@@ -44,7 +34,7 @@ module RubyLsp
             container_name: container.join("::"),
             kind: kind,
             location: Interface::Location.new(
-              uri: uri.to_s,
+              uri: entry.uri.to_s,
               range:  Interface::Range.new(
                 start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
                 end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
@@ -53,6 +43,24 @@ module RubyLsp
           )
         end
       end
+
+      private
+
+      #: -> Array[RubyIndexer::Entry]
+      def fuzzy_search
+        @index.fuzzy_search(@query) do |entry|
+          file_path = entry.uri.full_path
+
+          # We only show symbols declared in the workspace
+          in_dependencies = file_path && !not_in_dependencies?(file_path)
+          next if in_dependencies
+
+          # We should never show private symbols when searching the entire workspace
+          next if entry.private?
+
+          true
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -303,7 +303,7 @@ module RubyLsp
           @current_request_id,
           Interface::RelativePattern.new(
             base_uri: @global_state.workspace_uri.to_s,
-            pattern: "{.rubocop.yml,.rubocop}",
+            pattern: "{.rubocop.yml,.rubocop,.rubocop_todo.yml}",
           ),
           registration_id: "rubocop-watcher",
         ))
@@ -1045,7 +1045,7 @@ module RubyLsp
 
         file_name = File.basename(file_path)
 
-        if file_name == ".rubocop.yml" || file_name == ".rubocop"
+        if file_name == ".rubocop.yml" || file_name == ".rubocop" || file_name == ".rubocop_todo.yml"
           handle_rubocop_config_change(uri)
         end
       end

data/lib/ruby_lsp/setup_bundler.rb

@@ -234,13 +234,14 @@ module RubyLsp
         # If no error occurred, then clear previous errors
         @error_path.delete if @error_path.exist?
         $stderr.puts("Ruby LSP> Composed bundle installation complete")
-      rescue Errno::EPIPE
-        # If the $stderr pipe was closed by the client, for example when closing the editor during running bundle
-        # install, we don't want to write the error to a file or else we will report to telemetry on the next launch and
-        # it does not represent an actual error.
+      rescue Errno::EPIPE, Bundler::HTTPError
+        # There are cases where we expect certain errors to happen occasionally, and we don't want to write them to
+        # a file, which would report to telemetry on the next launch.
         #
-        # This situation may happen because while running bundle install, the server is not yet ready to receive
-        # shutdown requests and we may continue doing work until the process is killed.
+        # - The $stderr pipe might be closed by the client, for example when closing the editor during running bundle
+        # install. This situation may happen because, while running bundle install, the server is not yet ready to
+        # receive shutdown requests and we may continue doing work until the process is killed.
+        # - Bundler might also encounter a network error.
         @error_path.delete if @error_path.exist?
       rescue => e
         # Write the error object to a file so that we can read it from the parent process
@@ -269,12 +270,21 @@ module RubyLsp
     #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+
+      # The should_bundle_update? check needs to run on the original Bundler environment, but everything else (like
+      # updating or running install) requires the modified environment. Here we compute the check ahead of time and
+      # merge the environment to ensure correct results.
+      #
+      # The symptoms of having these operations in the wrong order is seeing unwanted modifications in the application's
+      # main lockfile because we accidentally run update on the main bundle instead of the composed one.
+      needs_update = should_bundle_update?
+      ENV.merge!(env)
+
       return update(env) if @needs_update_path.exist?
 
       # The ENV can only be merged after checking if an update is required because we depend on the original value of
       # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
-      FileUtils.touch(@needs_update_path) if should_bundle_update?
-      ENV.merge!(env)
+      FileUtils.touch(@needs_update_path) if needs_update
 
       $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
       missing_gems = bundle_check

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -35,10 +35,10 @@ module RubyLsp
       @io = begin
         # The environment variable is only used for tests. The extension always writes to the temporary file
         if port
-          TCPSocket.new("localhost", port)
+          socket(port)
         elsif File.exist?(port_db_path)
           db = JSON.load_file(port_db_path)
-          TCPSocket.new("localhost", db[Dir.pwd])
+          socket(db[Dir.pwd])
         else
           # For tests that don't spawn the TCP server
           require "stringio"
@@ -209,6 +209,14 @@ module RubyLsp
 
     private
 
+    #: (String) -> TCPSocket
+    def socket(port)
+      socket = TCPSocket.new("localhost", port)
+      socket.binmode
+      socket.sync = true
+      socket
+    end
+
     #: (String?, **untyped) -> void
     def send_message(method_name, **params)
       json_message = { method: method_name, params: params }.to_json

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.26.1
+  version: 0.26.3
 platform: ruby
 authors:
 - Shopify
@@ -163,6 +163,7 @@ files:
 - lib/ruby_lsp/requests/support/annotation.rb
 - lib/ruby_lsp/requests/support/common.rb
 - lib/ruby_lsp/requests/support/formatter.rb
+- lib/ruby_lsp/requests/support/package_url.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_formatter.rb
 - lib/ruby_lsp/requests/support/rubocop_runner.rb
@@ -216,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.2
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []