ruby-lsp 0.23.11 → 0.26.6

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -7,23 +7,17 @@ module RubyLsp
     # request is used to to resolve the edit field for a given code action, if it is not already provided in the
     # textDocument/codeAction response. We can use it for scenarios that require more computation such as refactoring.
     class CodeActionResolve < Request
-      extend T::Sig
       include Support::Common
 
       NEW_VARIABLE_NAME = "new_variable"
       NEW_METHOD_NAME = "new_method"
 
       class CodeActionError < StandardError; end
+      class EmptySelectionError < CodeActionError; end
+      class InvalidTargetRangeError < CodeActionError; end
+      class UnknownCodeActionError < CodeActionError; end
 
-      class Error < ::T::Enum
-        enums do
-          EmptySelection = new
-          InvalidTargetRange = new
-          UnknownCodeAction = new
-        end
-      end
-
-      sig { params(document: RubyDocument, global_state: GlobalState, code_action: T::Hash[Symbol, T.untyped]).void }
+      #: (RubyDocument document, GlobalState global_state, Hash[Symbol, untyped] code_action) -> void
       def initialize(document, global_state, code_action)
         super()
         @document = document
@@ -31,9 +25,10 @@ module RubyLsp
         @code_action = code_action
       end
 
-      sig { override.returns(T.any(Interface::CodeAction, Error)) }
+      # @override
+      #: -> (Interface::CodeAction)
       def perform
-        return Error::EmptySelection if @document.source.empty?
+        raise EmptySelectionError, "Invalid selection for refactor" if @document.source.empty?
 
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
@@ -47,26 +42,52 @@ module RubyLsp
              CodeActions::CREATE_ATTRIBUTE_ACCESSOR
           create_attribute_accessor
         else
-          Error::UnknownCodeAction
+          raise UnknownCodeActionError, "Unknown code action: #{@code_action[:title]}"
         end
       end
 
       private
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction)
       def switch_block_style
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        if source_range[:start] == source_range[:end]
+          block_context = @document.locate_node(
+            source_range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          node = block_context.node
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Cursor is not inside a block"
+          end
 
-        target = @document.locate_first_within_range(
-          @code_action.dig(:data, :range),
-          node_types: [Prism::CallNode],
-        )
+          # Find the call node at the block node's start position.
+          # This should be the call node whose block the cursor is inside of.
+          call_context = RubyDocument.locate(
+            @document.ast,
+            node.location.cached_start_code_units_offset(@document.code_units_cache),
+            node_types: [Prism::CallNode],
+            code_units_cache: @document.code_units_cache,
+          )
+          target = call_context.node
+          unless target.is_a?(Prism::CallNode) && target.block == node
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
+        else
+          target = @document.locate_first_within_range(
+            @code_action.dig(:data, :range),
+            node_types: [Prism::CallNode],
+          )
 
-        return Error::InvalidTargetRange unless target.is_a?(Prism::CallNode)
+          unless target.is_a?(Prism::CallNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
-        node = target.block
-        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
+          node = target.block
+          unless node.is_a?(Prism::BlockNode)
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
+        end
 
         indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
 
@@ -91,17 +112,17 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction)
       def refactor_variable
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
-          .locate(@document.parse_result.value,
+          .locate(@document.ast,
             start_index,
             node_types: [
               Prism::StatementsNode,
@@ -111,16 +132,20 @@ module RubyLsp
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
-        return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+        if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end)
+        end #: as !nil
 
-        return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
+        if closest_node.is_a?(Prism::MissingNode)
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         closest_node_loc = closest_node.location
         # If the parent expression is a single line block, then we have to extract it inside of the one-line block
@@ -151,9 +176,12 @@ module RubyLsp
           lines = @document.source.lines
 
           indentation_line = lines[indentation_line_number]
-          return Error::InvalidTargetRange unless indentation_line
+          unless indentation_line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
-          indentation = T.must(indentation_line[/\A */]).size
+          indentation = indentation_line[/\A */] #: as !nil
+            .size
 
           target_range = {
             start: { line: target_line, character: indentation },
@@ -161,7 +189,9 @@ module RubyLsp
           }
 
           line = lines[target_line]
-          return Error::InvalidTargetRange unless line
+          unless line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           variable_source = if line.strip.empty?
             "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
@@ -189,27 +219,31 @@ module RubyLsp
         )
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction)
       def refactor_method
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
         node_context = RubyDocument.locate(
-          @document.parse_result.value,
+          @document.ast,
           start_index,
           node_types: [Prism::DefNode],
           code_units_cache: @document.code_units_cache,
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange unless closest_node
+        unless closest_node
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         target_range = if closest_node.is_a?(Prism::DefNode)
           end_keyword_loc = closest_node.end_keyword_loc
-          return Error::InvalidTargetRange unless end_keyword_loc
+          unless end_keyword_loc
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           end_line = end_keyword_loc.end_line - 1
           character = end_keyword_loc.end_column
@@ -261,7 +295,7 @@ module RubyLsp
         )
       end
 
-      sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
+      #: (Hash[Symbol, untyped] range, String new_text) -> Interface::TextEdit
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
           range: Interface::Range.new(
@@ -272,7 +306,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::BlockNode, indentation: T.nilable(String)).returns(String) }
+      #: (Prism::BlockNode node, String? indentation) -> String
       def recursively_switch_nested_block_styles(node, indentation)
         parameters = node.parameters
         body = node.body
@@ -301,7 +335,7 @@ module RubyLsp
         source
       end
 
-      sig { params(body: Prism::Node, indentation: T.nilable(String)).returns(String) }
+      #: (Prism::Node body, String? indentation) -> String
       def switch_block_body(body, indentation)
         # Check if there are any nested blocks inside of the current block
         body_loc = body.location
@@ -330,7 +364,7 @@ module RubyLsp
         indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
       end
 
-      sig { returns(T.any(Interface::CodeAction, Error)) }
+      #: -> (Interface::CodeAction)
       def create_attribute_accessor
         source_range = @code_action.dig(:data, :range)
 
@@ -348,20 +382,12 @@ module RubyLsp
           )
           node = node_context.node
 
-          return Error::EmptySelection unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+          unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+            raise EmptySelectionError, "Invalid selection for refactor"
+          end
         end
 
-        node = T.cast(
-          node,
-          T.any(
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-          ),
-        )
+        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode
 
         node_context = @document.locate_node(
           {
@@ -375,20 +401,20 @@ module RubyLsp
           ],
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange if closest_node.nil?
+        if closest_node.nil?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         attribute_name = node.name[1..]
         indentation = " " * (closest_node.location.start_column + 2)
-        attribute_accessor_source = T.must(
-          case @code_action[:title]
-          when CodeActions::CREATE_ATTRIBUTE_READER
-            "#{indentation}attr_reader :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_WRITER
-            "#{indentation}attr_writer :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
-            "#{indentation}attr_accessor :#{attribute_name}\n\n"
-          end,
-        )
+        attribute_accessor_source = case @code_action[:title]
+        when CodeActions::CREATE_ATTRIBUTE_READER
+          "#{indentation}attr_reader :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_WRITER
+          "#{indentation}attr_writer :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          "#{indentation}attr_accessor :#{attribute_name}\n\n"
+        end #: as !nil
 
         target_start_line = closest_node.location.start_line
         target_range = {

data/lib/ruby_lsp/requests/code_actions.rb

@@ -7,8 +7,6 @@ module RubyLsp
     # request informs the editor of RuboCop quick fixes that can be applied. These are accessible by hovering over a
     # specific diagnostic.
     class CodeActions < Request
-      extend T::Sig
-
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
       TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
@@ -16,22 +14,17 @@ module RubyLsp
       CREATE_ATTRIBUTE_WRITER = "Create Attribute Writer"
       CREATE_ATTRIBUTE_ACCESSOR = "Create Attribute Accessor"
 
-      INSTANCE_VARIABLE_NODES = T.let(
-        [
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
+      INSTANCE_VARIABLE_NODES = [
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableReadNode,
+        Prism::InstanceVariableTargetNode,
+        Prism::InstanceVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::CodeActionRegistrationOptions) }
+        #: -> Interface::CodeActionRegistrationOptions
         def provider
           Interface::CodeActionRegistrationOptions.new(
             document_selector: nil,
@@ -40,22 +33,17 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          range: T::Hash[Symbol, T.untyped],
-          context: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, Hash[Symbol, untyped] range, Hash[Symbol, untyped] context) -> void
       def initialize(document, range, context)
         super()
         @document = document
-        @uri = T.let(document.uri, URI::Generic)
+        @uri = document.uri #: URI::Generic
         @range = range
         @context = context
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::CodeAction], Object))) }
+      # @override
+      #: -> (Array[Interface::CodeAction] & Object)?
       def perform
         diagnostics = @context[:diagnostics]
 
@@ -75,12 +63,8 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
-          code_actions << Interface::CodeAction.new(
-            title: TOGGLE_BLOCK_STYLE_TITLE,
-            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
-            data: { range: @range, uri: @uri.to_s },
-          )
         end
+        code_actions.concat(toggle_block_style_action)
         code_actions.concat(attribute_actions)
 
         code_actions
@@ -88,7 +72,7 @@ module RubyLsp
 
       private
 
-      sig { returns(T::Array[Interface::CodeAction]) }
+      #: -> Array[Interface::CodeAction]
       def attribute_actions
         return [] unless @document.is_a?(RubyDocument)
 
@@ -125,6 +109,25 @@ module RubyLsp
           ),
         ]
       end
+
+      #: -> Array[Interface::CodeAction]
+      def toggle_block_style_action
+        if @range[:start] == @range[:end]
+          block_context = @document.locate_node(
+            @range[:start],
+            node_types: [Prism::BlockNode],
+          )
+          return [] unless block_context.node.is_a?(Prism::BlockNode)
+        end
+
+        [
+          Interface::CodeAction.new(
+            title: TOGGLE_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,40 +11,50 @@ module RubyLsp
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
     # request informs the editor of runnable commands such as testing and debugging.
     class CodeLens < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::CodeLensOptions) }
+        #: -> Interface::CodeLensOptions
         def provider
-          Interface::CodeLensOptions.new(resolve_provider: false)
+          Interface::CodeLensOptions.new(resolve_provider: true)
         end
       end
 
-      sig do
-        params(
-          global_state: GlobalState,
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
-      def initialize(global_state, uri, dispatcher)
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        )
+      #: (GlobalState, RubyDocument | ERBDocument, Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
         super()
-        Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+
+        @document = document
+        @test_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+        uri = document.uri
+        file_path = uri.full_path
+        code_lens_config = global_state.feature_configuration(:codeLens)
+        test_lenses_enabled = (!code_lens_config || code_lens_config.enabled?(:enableTestCodeLens)) &&
+          file_path && File.fnmatch?(TEST_PATH_PATTERN, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+
+        if global_state.enabled_feature?(:fullTestDiscovery)
+          if test_lenses_enabled
+            Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
+            Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+          end
+        else
+          Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+        end
 
         Addon.addons.each do |addon|
           addon.create_code_lens_listener(@response_builder, uri, dispatcher)
+
+          if global_state.enabled_feature?(:fullTestDiscovery) && test_lenses_enabled
+            addon.create_discover_tests_listener(@test_builder, dispatcher, uri)
+          end
         end
       end
 
-      sig { override.returns(T::Array[Interface::CodeLens]) }
+      # @override
+      #: -> Array[Interface::CodeLens]
       def perform
-        @response_builder.response
+        @document.cache_set("rubyLsp/discoverTests", @test_builder.response)
+        @response_builder.response + @test_builder.code_lens
       end
     end
   end

data/lib/ruby_lsp/requests/completion.rb

@@ -8,12 +8,8 @@ module RubyLsp
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
     # suggests possible completions according to what the developer is typing.
     class Completion < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::CompletionOptions) }
+        #: -> Interface::CompletionOptions
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
@@ -25,18 +21,10 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          params: T::Hash[Symbol, T.untyped],
-          sorbet_level: RubyDocument::SorbetLevel,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
       def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
-        @target = T.let(nil, T.nilable(Prism::Node))
+        @target = nil #: Prism::Node?
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
@@ -45,7 +33,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: [
             Prism::CallNode,
@@ -72,10 +60,8 @@ module RubyLsp
           ],
           code_units_cache: document.code_units_cache,
         )
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
 
         Listeners::Completion.new(
           @response_builder,
@@ -102,7 +88,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T::Array[Interface::CompletionItem]) }
+      # @override
+      #: -> Array[Interface::CompletionItem]
       def perform
         return [] unless @target
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -14,21 +14,21 @@ module RubyLsp
     # At most 10 definitions are included, to ensure low latency during request processing and rendering the completion
     # item.
     class CompletionResolve < Request
-      extend T::Sig
       include Requests::Support::Common
 
       # set a limit on the number of documentation entries returned, to avoid rendering performance issues
       # https://github.com/Shopify/ruby-lsp/pull/1798
       MAX_DOCUMENTATION_ENTRIES = 10
 
-      sig { params(global_state: GlobalState, item: T::Hash[Symbol, T.untyped]).void }
+      #: (GlobalState global_state, Hash[Symbol, untyped] item) -> void
       def initialize(global_state, item)
         super()
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @index = global_state.index #: RubyIndexer::Index
         @item = item
       end
 
-      sig { override.returns(T::Hash[Symbol, T.untyped]) }
+      # @override
+      #: -> Hash[Symbol, untyped]
       def perform
         return @item if @item.dig(:data, :skip_resolve)
 
@@ -54,7 +54,7 @@ module RubyLsp
           end
         end
 
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
           label = +"#{label}#{first_entry.decorated_parameters}"
@@ -68,23 +68,25 @@ module RubyLsp
           "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
-        @item[:documentation] = Interface::MarkupContent.new(
-          kind: "markdown",
-          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
-        )
+        unless @item[:kind] == Constant::CompletionItemKind::FILE
+          @item[:documentation] = Interface::MarkupContent.new(
+            kind: "markdown",
+            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
+          )
+        end
 
         @item
       end
 
       private
 
-      sig { params(item: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      #: (Hash[Symbol, untyped] item) -> Hash[Symbol, untyped]
       def keyword_resolve(item)
         keyword = item[:label]
         content = KEYWORD_DOCS[keyword]
 
         if content
-          doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+          doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
 
           @item[:documentation] = Interface::MarkupContent.new(
             kind: "markdown",
@@ -93,7 +95,7 @@ module RubyLsp
               #{keyword}
               ```
 
-              [Read more](#{doc_path})
+              [Read more](#{doc_uri})
 
               #{content}
             MARKDOWN