ruby-lsp 0.23.11 → 0.26.4

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -1,27 +1,29 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/test_discovery"
 require "ruby_lsp/listeners/test_style"
+require "ruby_lsp/listeners/spec_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 }
+      #: (GlobalState global_state, RubyDocument document, Prism::Dispatcher 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)
+        @response_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+        @index = global_state.index #: RubyIndexer::Index
       end
 
-      sig { override.returns(T::Array[Support::TestItem]) }
+      # @override
+      #: -> Array[Support::TestItem]
       def perform
         uri = @document.uri
 
@@ -35,7 +37,13 @@ module RubyLsp
         # 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)
+          Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+          Addon.addons.each do |addon|
+            addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+          end
+
+          @dispatcher.visit(@document.ast)
         else
           @global_state.synchronize do
             RubyIndexer::DeclarationListener.new(
@@ -47,11 +55,16 @@ module RubyLsp
             )
 
             Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+            Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+            Addon.addons.each do |addon|
+              addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+            end
 
             # 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)
+            @dispatcher.visit(@document.ast)
           end
         end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -13,31 +13,20 @@ module RubyLsp
     # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
     # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
     class DocumentHighlight < Request
-      extend T::Sig
-
-      sig do
-        params(
-          global_state: GlobalState,
-          document: T.any(RubyDocument, ERBDocument),
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (GlobalState global_state, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, document, position, dispatcher)
         super()
         char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           code_units_cache: document.code_units_cache,
         )
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
         Listeners::DocumentHighlight.new(
           @response_builder,
           node_context.node,
@@ -47,7 +36,8 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(T::Array[Interface::DocumentHighlight]) }
+      # @override
+      #: -> Array[Interface::DocumentHighlight]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_link.rb

@@ -9,34 +9,23 @@ module RubyLsp
     # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
     # When the user clicks the link, it'll open that location.
     class DocumentLink < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentLinkOptions) }
+        #: -> Interface::DocumentLinkOptions
         def provider
           Interface::DocumentLinkOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          uri: URI::Generic,
-          comments: T::Array[Prism::Comment],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (URI::Generic uri, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
         Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::DocumentLink]) }
+      # @override
+      #: -> Array[Interface::DocumentLink]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -13,21 +13,17 @@ module RubyLsp
     # In VS Code, symbol search known as 'Go To Symbol in Editor' and can be accessed with Ctrl/Cmd-Shift-O,
     # or by opening the command palette and inserting an `@` symbol.
     class DocumentSymbol < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentSymbolOptions) }
+        #: -> Interface::DocumentSymbolOptions
         def provider
           Interface::DocumentSymbolOptions.new
         end
       end
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      #: (URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, dispatcher)
         super()
-        @response_builder = T.let(ResponseBuilders::DocumentSymbol.new, ResponseBuilders::DocumentSymbol)
+        @response_builder = ResponseBuilders::DocumentSymbol.new #: ResponseBuilders::DocumentSymbol
         Listeners::DocumentSymbol.new(@response_builder, uri, dispatcher)
 
         Addon.addons.each do |addon|
@@ -35,7 +31,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -8,31 +8,23 @@ module RubyLsp
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.
     class FoldingRanges < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      #: (Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
-        )
-        @listener = T.let(
-          Listeners::FoldingRanges.new(@response_builder, comments, dispatcher),
-          Listeners::FoldingRanges,
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+        @listener = Listeners::FoldingRanges.new(@response_builder, comments, dispatcher) #: Listeners::FoldingRanges
       end
 
-      sig { override.returns(T::Array[Interface::FoldingRange]) }
+      # @override
+      #: -> Array[Interface::FoldingRange]
       def perform
         @listener.finalize_response!
         @response_builder.response

data/lib/ruby_lsp/requests/formatting.rb

@@ -7,28 +7,25 @@ module RubyLsp
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
     class Formatting < Request
-      extend T::Sig
-
       class Error < StandardError; end
 
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(global_state: GlobalState, document: RubyDocument).void }
+      #: (GlobalState global_state, RubyDocument document) -> void
       def initialize(global_state, document)
         super()
         @document = document
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
-        @uri = T.let(document.uri, URI::Generic)
+        @active_formatter = global_state.active_formatter #: Support::Formatter?
+        @uri = document.uri #: URI::Generic
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      # @override
+      #: -> (Array[Interface::TextEdit] & Object)?
       def perform
         return unless @active_formatter
         return if @document.syntax_error?

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -0,0 +1,139 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # GoTo Relevant File is a custom [LSP
+    # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage)
+    # that navigates to the relevant file for the current document.
+    # Currently, it supports source code file <> test file navigation.
+    class GoToRelevantFile < Request
+      TEST_KEYWORDS = ["test", "spec", "integration_test"]
+
+      TEST_PREFIX_PATTERN = /^(#{TEST_KEYWORDS.join("_|")}_)/
+      TEST_SUFFIX_PATTERN = /(_#{TEST_KEYWORDS.join("|_")})$/
+      TEST_PATTERN = /#{TEST_PREFIX_PATTERN}|#{TEST_SUFFIX_PATTERN}/
+
+      TEST_PREFIX_GLOB = "#{TEST_KEYWORDS.join("_,")}_" #: String
+      TEST_SUFFIX_GLOB = "_#{TEST_KEYWORDS.join(",_")}" #: String
+
+      #: (String path, String workspace_path) -> void
+      def initialize(path, workspace_path)
+        super()
+
+        @workspace_path = workspace_path
+        @path = path.delete_prefix(workspace_path) #: String
+      end
+
+      # @override
+      #: -> Array[String]
+      def perform
+        find_relevant_paths
+      end
+
+      private
+
+      #: -> Array[String]
+      def find_relevant_paths
+        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 { |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 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
+
+          # 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
+
+          # 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
+      # input path and the candidate relevant file paths.
+      # Ref: https://en.wikipedia.org/wiki/Jaccard_index
+      # The main idea of this algorithm is to take the size of interaction and divide
+      # it by the size of union between two sets (in our case the elements in each set
+      # would be the parts of the path separated by path divider.)
+      #: (Array[String] candidates) -> Array[String]
+      def find_most_similar_with_jaccard(candidates)
+        dirs = get_dir_parts(@path)
+
+        _, results = candidates
+          .group_by do |other_path|
+            other_dirs = get_dir_parts(other_path)
+            # Similarity score between the two directories
+            (dirs & other_dirs).size.to_f / (dirs | other_dirs).size
+          end
+          .max_by(&:first)
+
+        results || []
+      end
+
+      #: (String path) -> Set[String]
+      def get_dir_parts(path)
+        Set.new(File.dirname(path).split(File::SEPARATOR))
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/hover.rb

@@ -7,30 +7,16 @@ module RubyLsp
   module Requests
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # displays the documentation for the symbol currently under the cursor.
+    #: [ResponseType = Interface::Hover?]
     class Hover < Request
-      extend T::Sig
-      extend T::Generic
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::HoverOptions) }
+        #: -> Interface::HoverOptions
         def provider
           Interface::HoverOptions.new
         end
       end
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
-
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
@@ -38,7 +24,7 @@ module RubyLsp
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
           code_units_cache: document.code_units_cache,
@@ -48,8 +34,8 @@ module RubyLsp
 
         if should_refine_target?(parent, target)
           target = determine_target(
-            T.must(target),
-            T.must(parent),
+            target, #: as !nil
+            parent, #: as !nil
             position,
           )
         elsif position_outside_target?(position, target)
@@ -59,9 +45,9 @@ module RubyLsp
         # Don't need to instantiate any listeners if there's no target
         return unless target
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
         uri = document.uri
-        @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
+        @response_builder = ResponseBuilders::Hover.new #: ResponseBuilders::Hover
         Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
@@ -70,7 +56,8 @@ module RubyLsp
         @dispatcher = dispatcher
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def perform
         return unless @target
 
@@ -88,14 +75,14 @@ module RubyLsp
 
       private
 
-      sig { params(parent: T.nilable(Prism::Node), target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? parent, Prism::Node? target) -> bool
       def should_refine_target?(parent, target)
         (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
         !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
           (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
       end
 
-      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool
       def position_outside_target?(position, target)
         case target
         when Prism::GlobalVariableAndWriteNode,

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,35 +9,24 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     class InlayHints < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::InlayHintOptions) }
+        #: -> Interface::InlayHintOptions
         def provider
           Interface::InlayHintOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          hints_configuration: RequestConfig,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
-      def initialize(document, hints_configuration, dispatcher)
+      #: (GlobalState, (RubyDocument | ERBDocument), Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
         super()
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-        )
-        Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
+        Listeners::InlayHints.new(global_state, @response_builder, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::InlayHint]) }
+      # @override
+      #: -> Array[Interface::InlayHint]
       def perform
         @response_builder.response
       end