ruby-lsp 0.7.6 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a645362acbfb8b0f819bd89fbaf1e53d0f7d9eda81974e62bc0f114aeefc221e
-  data.tar.gz: 861b5c68f9355f551ebfb519507ca1c0028f0e4e2edff70ae6ad62c652bdfd2c
+  metadata.gz: ed62114ae68bf84cf95f96a2517bc2e729ebaf572500b3871f253bc4b584d7ba
+  data.tar.gz: d34dd2719e3b8088f59f4c38988b3fa7058c866a0d34b8b0b0ea391e18ec64d2
 SHA512:
-  metadata.gz: 4283abdb1ce9865e6dbecd0827ddd88f07a63937a9f75ba8ca78142d3536624ac374b165e7a1277adee4197553c74615ed560dad3093eb346ae3e505e174dae5
-  data.tar.gz: 6084fd63d0d780c169b8f8766f347cdb699e2490a0c8de542a3fa969ad37d7f49e281ffa7f92a7ee15a764dccac9832e5e9a49265ba9077f9d204185d0c00e64
+  metadata.gz: d9d7bdf1a6ce4d3a7711a0032236d25d3b79682239f801354c15c01661a8e3b1110be90dd503e1d75dcd442520893d6cc852ef5a1eaeeb5a0834305a1c3350c7
+  data.tar.gz: f55f82e138cb65fb7450afe86092d294bca06bcd6043439723567ed6538a1b373eed10ba5f3702e9d17f16fc4faa6b5447c048fb5683388e52bea1588d23dc63

data/VERSION

@@ -1 +1 @@
-0.7.6
+0.8.0

data/exe/ruby-lsp-check

@@ -30,13 +30,13 @@ message_queue = Thread::Queue.new
 executor = RubyLsp::Executor.new(store, message_queue)
 
 files.each_with_index do |file, index|
-  uri = "file://#{file}"
+  uri = URI("file://#{file}")
   store.set(uri: uri, source: File.read(file), version: 1)
 
   # Executing any of the automatic requests will execute all of them, so here we just pick one
   result = executor.execute({
     method: "textDocument/documentSymbol",
-    params: { textDocument: { uri: uri } },
+    params: { textDocument: { uri: uri.to_s } },
   })
 
   error = result.error

data/lib/core_ext/uri.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module URI
+  class Generic
+    class << self
+      extend T::Sig
+
+      sig { params(path: String, scheme: String).returns(URI::Generic) }
+      def from_path(path:, scheme: "file")
+        # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
+        escaped_path = if /^[A-Z]:/.match?(path)
+          DEFAULT_PARSER.escape("/#{path}")
+        else
+          DEFAULT_PARSER.escape(path)
+        end
+
+        build(scheme: scheme, path: escaped_path)
+      end
+    end
+
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    def to_standardized_path
+      parsed_path = path
+      return unless parsed_path
+
+      # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
+      # slash
+      actual_path = if %r{^/[A-Z]:}.match?(parsed_path)
+        parsed_path.delete_prefix("/")
+      else
+        parsed_path
+      end
+
+      CGI.unescape(actual_path)
+    end
+
+    sig { returns(String) }
+    def storage_key
+      T.must(to_standardized_path || opaque)
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -18,16 +18,16 @@ module RubyLsp
     sig { returns(Integer) }
     attr_reader :version
 
-    sig { returns(String) }
+    sig { returns(URI::Generic) }
     attr_reader :uri
 
-    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: String).void }
     def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
       @cache = T.let({}, T::Hash[String, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
       @version = T.let(version, Integer)
-      @uri = T.let(uri, String)
+      @uri = T.let(uri, URI::Generic)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))

data/lib/ruby_lsp/executor.rb

@@ -35,7 +35,7 @@ module RubyLsp
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
     def run(request)
-      uri = request.dig(:params, :textDocument, :uri)
+      uri = URI(request.dig(:params, :textDocument, :uri).to_s)
 
       case request[:method]
       when "initialize"
@@ -70,7 +70,7 @@ module RubyLsp
       when "textDocument/didClose"
         @message_queue << Notification.new(
           message: "textDocument/publishDiagnostics",
-          params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
+          params: Interface::PublishDiagnosticsParams.new(uri: uri.to_s, diagnostics: []),
         )
 
         text_document_did_close(uri)
@@ -174,12 +174,12 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
+    sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
       { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
     end
 
-    sig { params(uri: String, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
+    sig { params(uri: URI::Generic, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
     def definition(uri, position)
       document = @store.get(uri)
       return if document.syntax_error?
@@ -192,7 +192,7 @@ module RubyLsp
       base_listener.response
     end
 
-    sig { params(uri: String).returns(T::Array[Interface::FoldingRange]) }
+    sig { params(uri: URI::Generic).returns(T::Array[Interface::FoldingRange]) }
     def folding_range(uri)
       @store.cache_fetch(uri, "textDocument/foldingRange") do |document|
         Requests::FoldingRanges.new(document).run
@@ -201,7 +201,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
       ).returns(T.nilable(Interface::Hover))
     end
@@ -227,19 +227,19 @@ module RubyLsp
       hover.response
     end
 
-    sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    sig { params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
     end
 
-    sig { params(uri: String, text: String, version: Integer).returns(Object) }
+    sig { params(uri: URI::Generic, text: String, version: Integer).returns(Object) }
     def text_document_did_open(uri, text, version)
       @store.set(uri: uri, source: text, version: version)
       VOID
     end
 
-    sig { params(uri: String).returns(Object) }
+    sig { params(uri: URI::Generic).returns(Object) }
     def text_document_did_close(uri)
       @store.delete(uri)
       VOID
@@ -247,7 +247,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         positions: T::Array[Document::PositionShape],
       ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
     end
@@ -270,7 +270,7 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
+    sig { params(uri: URI::Generic).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       return if @store.formatter == "none"
@@ -280,7 +280,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
         character: String,
       ).returns(T::Array[Interface::TextEdit])
@@ -291,7 +291,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
       ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
     end
@@ -306,7 +306,7 @@ module RubyLsp
       listener.response
     end
 
-    sig { params(uri: String, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
+    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
     def inlay_hint(uri, range)
       document = @store.get(uri)
       return if document.syntax_error?
@@ -322,7 +322,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         range: Document::RangeShape,
         context: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::CodeAction]))
@@ -335,7 +335,7 @@ module RubyLsp
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
     def code_action_resolve(params)
-      uri = params.dig(:data, :uri)
+      uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
       result = Requests::CodeActionResolve.new(document, params).run
 
@@ -363,7 +363,7 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
+    sig { params(uri: URI::Generic).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(document).run
@@ -372,7 +372,7 @@ module RubyLsp
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
     end
 
-    sig { params(uri: String, range: Document::RangeShape).returns(Interface::SemanticTokens) }
+    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(Interface::SemanticTokens) }
     def semantic_tokens_range(uri, range)
       document = @store.get(uri)
       start_line = range.dig(:start, :line)
@@ -390,7 +390,10 @@ module RubyLsp
     end
 
     sig do
-      params(uri: String, position: Document::PositionShape).returns(T.nilable(T::Array[Interface::CompletionItem]))
+      params(
+        uri: URI::Generic,
+        position: Document::PositionShape,
+      ).returns(T.nilable(T::Array[Interface::CompletionItem]))
     end
     def completion(uri, position)
       document = @store.get(uri)

data/lib/ruby_lsp/extension.rb

@@ -97,8 +97,32 @@ module RubyLsp
     sig { abstract.void }
     def activate; end
 
+    # Each extension should implement `MyExtension#deactivate` and use to perform any clean up, like shutting down a
+    # child process
+    sig { abstract.void }
+    def deactivate; end
+
     # Extensions should override the `name` method to return the extension name
     sig { abstract.returns(String) }
     def name; end
+
+    # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+    sig do
+      overridable.params(
+        uri: URI::Generic,
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
+    end
+    def create_code_lens_listener(uri, emitter, message_queue); end
+
+    # Creates a new Hover listener. This method is invoked on every Hover request
+    sig do
+      overridable.params(
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
+    end
+    def create_hover_listener(emitter, message_queue); end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -7,8 +7,10 @@ require "language_server-protocol"
 require "benchmark"
 require "bundler"
 require "uri"
+require "cgi"
 
 require "ruby-lsp"
+require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"

data/lib/ruby_lsp/listener.rb

@@ -18,25 +18,26 @@ module RubyLsp
     def initialize(emitter, message_queue)
       @emitter = emitter
       @message_queue = message_queue
-    end
-
-    class << self
-      extend T::Sig
-
-      sig { returns(T::Array[T.class_of(Listener)]) }
-      def listeners
-        @listeners ||= T.let([], T.nilable(T::Array[T.class_of(Listener)]))
-      end
-
-      sig { params(listener: T.class_of(Listener)).void }
-      def add_listener(listener)
-        listeners << listener
-      end
+      @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
     end
 
     # Override this method with an attr_reader that returns the response of your listener. The listener should
     # accumulate results in a @response variable and then provide the reader so that it is accessible
     sig { abstract.returns(ResponseType) }
     def response; end
+
+    # Merge responses from all external listeners into the base listener's response. We do this to return a single
+    # response to the editor including the results of all extensions
+    sig { void }
+    def merge_external_listeners_responses!
+      @external_listeners.each { |l| merge_response!(l) }
+    end
+
+    # Does nothing by default. Requests that accept extensions should override this method to define how to merge
+    # responses coming from external listeners
+    sig { overridable.params(other: Listener[T.untyped]).returns(T.self_type) }
+    def merge_response!(other)
+      self
+    end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -29,7 +29,7 @@ module RubyLsp
       def initialize(document, range, context)
         super(document)
 
-        @uri = T.let(document.uri, String)
+        @uri = T.let(document.uri, URI::Generic)
         @range = range
         @context = context
       end
@@ -63,14 +63,14 @@ module RubyLsp
           )
       end
 
-      sig { params(range: Document::RangeShape, uri: String).returns(Interface::CodeAction) }
+      sig { params(range: Document::RangeShape, uri: URI::Generic).returns(Interface::CodeAction) }
       def refactor_code_action(range, uri)
         Interface::CodeAction.new(
           title: "Refactor: Extract Variable",
           kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
           data: {
             range: range,
-            uri: uri,
+            uri: uri.to_s,
           },
         )
       end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -31,15 +31,17 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
       def initialize(uri, emitter, message_queue, test_library)
         super(emitter, message_queue)
 
-        @uri = T.let(uri, String)
-        @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
+        @uri = T.let(uri, URI::Generic)
+        @external_listeners.concat(
+          Extension.extensions.filter_map { |ext| ext.create_code_lens_listener(uri, emitter, message_queue) },
+        )
         @test_library = T.let(test_library, String)
         @response = T.let([], ResponseType)
-        @path = T.let(T.must(URI(uri).path), String)
+        @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([["public", "public"]], T::Array[T::Array[T.nilable(String)]])
         @class_stack = T.let([], T::Array[String])
@@ -55,22 +57,6 @@ module RubyLsp
           :after_call,
           :on_vcall,
         )
-
-        register_external_listeners!
-      end
-
-      sig { void }
-      def register_external_listeners!
-        self.class.listeners.each do |l|
-          @external_listeners << T.unsafe(l).new(@uri, @emitter, @message_queue)
-        end
-      end
-
-      sig { void }
-      def merge_external_listeners_responses!
-        @external_listeners.each do |l|
-          merge_response!(l)
-        end
       end
 
       sig { params(node: SyntaxTree::ClassDeclaration).void }
@@ -120,7 +106,7 @@ module RubyLsp
         if ACCESS_MODIFIERS.include?(node_message) && node.arguments.parts.any?
           visibility, _ = @visibility_stack.pop
           @visibility_stack.push([node_message, visibility])
-        elsif @path.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
+        elsif @path&.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
           remote = resolve_gem_remote(node)
           return unless remote
 
@@ -163,7 +149,7 @@ module RubyLsp
         end
       end
 
-      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
         @response.concat(other.response)
         self
@@ -174,7 +160,7 @@ module RubyLsp
       sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library)
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library) && @path
 
         arguments = [
           @path,
@@ -231,7 +217,7 @@ module RubyLsp
 
       sig { params(class_name: String, method_name: T.nilable(String)).returns(String) }
       def generate_test_command(class_name:, method_name: nil)
-        command = BASE_COMMAND + @path
+        command = BASE_COMMAND + T.must(@path)
 
         case @test_library
         when "minitest"

data/lib/ruby_lsp/requests/definition.rb

@@ -25,7 +25,7 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(uri, emitter, message_queue)
         super(emitter, message_queue)
 
@@ -53,7 +53,7 @@ module RubyLsp
 
           if candidate
             @response = Interface::Location.new(
-              uri: "file://#{candidate}",
+              uri: URI::Generic.from_path(path: candidate).to_s,
               range: Interface::Range.new(
                 start: Interface::Position.new(line: 0, character: 0),
                 end: Interface::Position.new(line: 0, character: 0),
@@ -61,13 +61,13 @@ module RubyLsp
             )
           end
         when "require_relative"
-          current_file = T.must(URI.parse(@uri).path)
-          current_folder = Pathname.new(current_file).dirname
+          path = @uri.to_standardized_path
+          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
           candidate = File.expand_path(File.join(current_folder, required_file))
 
           if candidate
             @response = Interface::Location.new(
-              uri: "file://#{candidate}",
+              uri: URI::Generic.from_path(path: candidate).to_s,
               range: Interface::Range.new(
                 start: Interface::Position.new(line: 0, character: 0),
                 end: Interface::Position.new(line: 0, character: 0),

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -25,7 +25,7 @@ module RubyLsp
       def initialize(document)
         super(document)
 
-        @uri = T.let(document.uri, String)
+        @uri = T.let(document.uri, URI::Generic)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
@@ -36,7 +36,8 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless URI(@uri).path&.start_with?(T.must(WORKSPACE_URI.path))
+        path = @uri.to_standardized_path
+        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_link.rb

@@ -75,13 +75,14 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(uri, emitter, message_queue)
         super(emitter, message_queue)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
-        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        path = uri.to_standardized_path
+        version_match = path ? /(?<=%40)[\d.]+(?=\.rbi$)/.match(path) : nil
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
         @response = T.let([], T::Array[Interface::DocumentLink])
 
@@ -95,7 +96,7 @@ module RubyLsp
 
         uri = T.cast(URI(T.must(match[0])), URI::Source)
         gem_version = T.must(resolve_version(uri))
-        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(uri.path))
         return if file_path.nil?
 
         @response << Interface::DocumentLink.new(

data/lib/ruby_lsp/requests/formatting.rb

@@ -58,7 +58,7 @@ module RubyLsp
       def initialize(document, formatter: "auto")
         super(document)
 
-        @uri = T.let(document.uri, String)
+        @uri = T.let(document.uri, URI::Generic)
         @formatter = formatter
       end
 
@@ -67,7 +67,8 @@ module RubyLsp
         return if @formatter == "none"
 
         # Don't try to format files outside the current working directory
-        return unless @uri.sub("file://", "").start_with?(Dir.pwd)
+        path = @uri.to_standardized_path
+        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
 
         return if @document.syntax_error?
 

data/lib/ruby_lsp/requests/hover.rb

@@ -39,29 +39,15 @@ module RubyLsp
       def initialize(emitter, message_queue)
         super
 
-        @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
+        @external_listeners.concat(
+          Extension.extensions.filter_map { |ext| ext.create_hover_listener(emitter, message_queue) },
+        )
         @response = T.let(nil, ResponseType)
         emitter.register(self, :on_command, :on_const_path_ref, :on_call)
-
-        register_external_listeners!
-      end
-
-      sig { void }
-      def register_external_listeners!
-        self.class.listeners.each do |l|
-          @external_listeners << T.unsafe(l).new(@emitter, @message_queue)
-        end
-      end
-
-      sig { void }
-      def merge_external_listeners_responses!
-        @external_listeners.each do |l|
-          merge_response!(l)
-        end
       end
 
       # Merges responses from other hover listeners
-      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
         other_response = other.response
         return self unless other_response

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

@@ -10,7 +10,7 @@ module RubyLsp
 
         interface!
 
-        sig { abstract.params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { abstract.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
         def run(uri, document); end
       end
     end

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

@@ -19,7 +19,7 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
-        sig { params(offense: RuboCop::Cop::Offense, uri: String).void }
+        sig { params(offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(offense, uri)
           @offense = offense
           @uri = uri
@@ -34,7 +34,7 @@ module RubyLsp
               document_changes: [
                 Interface::TextDocumentEdit.new(
                   text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
-                    uri: @uri,
+                    uri: @uri.to_s,
                     version: nil,
                   ),
                   edits: @offense.correctable? ? offense_replacements : [],

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

@@ -3,7 +3,6 @@
 
 return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
-require "cgi"
 require "singleton"
 
 module RubyLsp
@@ -19,9 +18,9 @@ module RubyLsp
           @runner = T.let(RuboCopRunner.new, RuboCopRunner)
         end
 
-        sig { params(uri: String, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
+        sig { params(uri: URI::Generic, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
         def run(uri, document)
-          filename = CGI.unescape(URI.parse(uri).path)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
           # Invoke RuboCop with just this file in `paths`
           @runner.run(filename, document.source)
 

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

@@ -3,7 +3,6 @@
 
 return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
-require "cgi"
 require "singleton"
 
 module RubyLsp
@@ -21,9 +20,9 @@ module RubyLsp
           @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { override.params(uri: String, document: Document).returns(String) }
+        sig { override.params(uri: URI::Generic, document: Document).returns(String) }
         def run(uri, document)
-          filename = CGI.unescape(URI.parse(uri).path)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
 
           # Invoke RuboCop with just this file in `paths`
           @runner.run(filename, document.source)

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

@@ -26,9 +26,10 @@ module RubyLsp
             )
         end
 
-        sig { override.params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
-          relative_path = Pathname.new(URI(uri).path).relative_path_from(T.must(WORKSPACE_URI.path))
+          relative_path = Pathname.new(T.must(uri.to_standardized_path || uri.opaque))
+            .relative_path_from(T.must(WORKSPACE_URI.to_standardized_path))
           return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }
 
           SyntaxTree.format(

data/lib/ruby_lsp/server.rb

@@ -86,6 +86,7 @@ module RubyLsp
           @message_dispatcher.join
           @store.clear
 
+          Extension.extensions.each(&:deactivate)
           finalize_request(Result.new(response: nil), request)
         when "exit"
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
@@ -105,7 +106,7 @@ module RubyLsp
             # source. Altering the source reference during parsing will put the parser in an invalid internal state,
             # since it started parsing with one source but then it changed in the middle
             uri = request.dig(:params, :textDocument, :uri)
-            @store.get(uri).parse if uri
+            @store.get(URI(uri)).parse if uri
           end
 
           @job_queue << job
@@ -192,7 +193,14 @@ module RubyLsp
         params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
       end
 
-      params[:uri] = uri.sub(%r{.*://#{Dir.home}}, "~") if uri
+      if uri
+        home = URI::Generic.from_path(path: Dir.home)
+
+        parsed_uri = URI(uri)
+        path = parsed_uri.path
+        params[:uri] = path ? path.sub(T.must(home.path), "~") : parsed_uri.opaque
+      end
+
       params
     end
   end

data/lib/ruby_lsp/setup_bundler.rb

@@ -5,6 +5,7 @@ require "sorbet-runtime"
 require "bundler"
 require "fileutils"
 require "pathname"
+require "digest"
 
 # This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
 # the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
@@ -24,6 +25,7 @@ module RubyLsp
       @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(Dir.pwd), Pathname)
       @custom_gemfile = T.let(@custom_dir + "Gemfile", Pathname)
       @custom_lockfile = T.let(@custom_dir + "Gemfile.lock", Pathname)
+      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -37,7 +39,6 @@ module RubyLsp
       @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
 
       @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
-      @custom_bundle_dependencies = T.let(custom_bundle_dependencies, T::Hash[String, T.untyped])
     end
 
     # Setups up the custom bundle and returns the `BUNDLE_GEMFILE` and `BUNDLE_PATH` that should be used for running the
@@ -69,14 +70,16 @@ module RubyLsp
         return run_bundle_install(@custom_gemfile)
       end
 
-      # If .ruby-lsp/Gemfile.lock already exists and the top level Gemfile.lock hasn't been modified since it was last
-      # updated, then we're ready to boot the server
-      if @custom_lockfile.exist? && @custom_lockfile.stat.mtime > @lockfile.stat.mtime
+      lockfile_contents = @lockfile.read
+      current_lockfile_hash = Digest::SHA256.hexdigest(lockfile_contents)
+
+      if @custom_lockfile.exist? && @lockfile_hash_path.exist? && @lockfile_hash_path.read == current_lockfile_hash
         warn("Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date")
         return run_bundle_install(@custom_gemfile)
       end
 
       FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
+      @lockfile_hash_path.write(current_lockfile_hash)
       run_bundle_install(@custom_gemfile)
     end
 
@@ -84,10 +87,17 @@ module RubyLsp
 
     sig { returns(T::Hash[String, T.untyped]) }
     def custom_bundle_dependencies
-      return {} unless @custom_lockfile.exist?
-
-      ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
-      Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+      @custom_bundle_dependencies ||= T.let(
+        begin
+          if @custom_lockfile.exist?
+            ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
+            Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+          else
+            {}
+          end
+        end,
+        T.nilable(T::Hash[String, T.untyped]),
+      )
     ensure
       ENV.delete("BUNDLE_GEMFILE")
     end
@@ -160,7 +170,7 @@ module RubyLsp
       command = +""
 
       if (@dependencies["ruby-lsp"] && @dependencies["debug"]) ||
-          @custom_bundle_dependencies["ruby-lsp"].nil? || @custom_bundle_dependencies["debug"].nil?
+          custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil?
         # Install gems using the custom bundle
         command << "bundle install "
       else

data/lib/ruby_lsp/store.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "cgi"
-require "uri"
 require "ruby_lsp/document"
 
 module RubyLsp
@@ -22,24 +20,27 @@ module RubyLsp
       @formatter = T.let("auto", String)
     end
 
-    sig { params(uri: String).returns(Document) }
+    sig { params(uri: URI::Generic).returns(Document) }
     def get(uri)
-      document = @state[uri]
+      path = uri.to_standardized_path
+      return T.must(@state[T.must(uri.opaque)]) unless path
+
+      document = @state[path]
       return document unless document.nil?
 
-      set(uri: uri, source: File.binread(CGI.unescape(URI.parse(uri).path)), version: 0)
-      T.must(@state[uri])
+      set(uri: uri, source: File.binread(CGI.unescape(path)), version: 0)
+      T.must(@state[path])
     end
 
-    sig { params(uri: String, source: String, version: Integer).void }
+    sig { params(uri: URI::Generic, source: String, version: Integer).void }
     def set(uri:, source:, version:)
       document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
-      @state[uri] = document
+      @state[uri.storage_key] = document
     end
 
-    sig { params(uri: String, edits: T::Array[Document::EditShape], version: Integer).void }
+    sig { params(uri: URI::Generic, edits: T::Array[Document::EditShape], version: Integer).void }
     def push_edits(uri:, edits:, version:)
-      T.must(@state[uri]).push_edits(edits, version: version)
+      T.must(@state[uri.storage_key]).push_edits(edits, version: version)
     end
 
     sig { void }
@@ -52,15 +53,15 @@ module RubyLsp
       @state.empty?
     end
 
-    sig { params(uri: String).void }
+    sig { params(uri: URI::Generic).void }
     def delete(uri)
-      @state.delete(uri)
+      @state.delete(uri.storage_key)
     end
 
     sig do
       type_parameters(:T)
         .params(
-          uri: String,
+          uri: URI::Generic,
           request_name: String,
           block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))

data/lib/ruby_lsp/utils.rb

@@ -6,7 +6,7 @@ module RubyLsp
   VOID = T.let(Object.new.freeze, Object)
 
   # This freeze is not redundant since the interpolated string is mutable
-  WORKSPACE_URI = T.let(URI("file://#{Dir.pwd}".freeze), URI::Generic)
+  WORKSPACE_URI = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
 
   # A notification to be sent to the client
   class Message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.8.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-02 00:00:00.000000000 Z
+date: 2023-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -72,6 +72,7 @@ files:
 - VERSION
 - exe/ruby-lsp
 - exe/ruby-lsp-check
+- lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
 - lib/ruby_lsp/check_docs.rb