ruby-lsp 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4825b35aef41194e36092d705d02735786950d140842c20d210ae79ece322a00
-  data.tar.gz: 980bb51fca93844ec0e2bcf2ce57779441fd90a243bf8dab1c30d6dec683e438
+  metadata.gz: ed62114ae68bf84cf95f96a2517bc2e729ebaf572500b3871f253bc4b584d7ba
+  data.tar.gz: d34dd2719e3b8088f59f4c38988b3fa7058c866a0d34b8b0b0ea391e18ec64d2
 SHA512:
-  metadata.gz: 5ce7d7401bf7a817a90b6cabeb3d2da7bcc7115d5cb2bf38d5866d4e30061eab615e1fc5366059e7c46630701e11345eb00ac8a09d171d17864ec7fae2ef5a58
-  data.tar.gz: cb90d3684d0ea67aa35b53ff694821ecac2b30d43a878a6b24ac6bed873c8ed1eb284fb94a01f4295abda13a612dc0c757e233e0e6a96b2ab70e08c1ce2ddaf1
+  metadata.gz: d9d7bdf1a6ce4d3a7711a0032236d25d3b79682239f801354c15c01661a8e3b1110be90dd503e1d75dcd442520893d6cc852ef5a1eaeeb5a0834305a1c3350c7
+  data.tar.gz: f55f82e138cb65fb7450afe86092d294bca06bcd6043439723567ed6538a1b373eed10ba5f3702e9d17f16fc4faa6b5447c048fb5683388e52bea1588d23dc63

data/VERSION

@@ -1 +1 @@
-0.7.5
+0.8.0

data/exe/ruby-lsp

@@ -1,32 +1,21 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# We should make sure that, if we're running on a bundler project, that it has a Gemfile.lock
-if File.exist?("Gemfile") && !File.exist?("Gemfile.lock")
-  warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
-  exit(78)
-end
-
 # When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
 # using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
 # the application's bundle
-if ENV["BUNDLE_GEMFILE"].nil? && File.exist?("Gemfile.lock")
+if ENV["BUNDLE_GEMFILE"].nil?
   require_relative "../lib/ruby_lsp/setup_bundler"
-  RubyLsp::SetupBundler.new(Dir.pwd).setup!
-
-  # In some cases, like when the `ruby-lsp` is already a part of the bundle, we don't generate `.ruby-lsp/Gemfile`.
-  # However, we still want to run the server with `bundle exec`. We need to make sure we're pointing to the right
-  # `Gemfile`
-  bundle_gemfile = File.exist?(".ruby-lsp/Gemfile") ? ".ruby-lsp/Gemfile" : "Gemfile"
 
-  # In addition to BUNDLE_GEMFILE, we also need to make sure that BUNDLE_PATH is absolute and not relative. For example,
-  # if BUNDLE_PATH is `vendor/bundle`, we want the top level `vendor/bundle` and not `.ruby-lsp/vendor/bundle`.
-  # Expanding to get the absolute path ensures we're pointing to the correct folder, which is the same one we use in
-  # SetupBundler to install the gems
-  path = Bundler.settings["path"]
+  begin
+    bundle_gemfile, bundle_path = RubyLsp::SetupBundler.new(Dir.pwd).setup!
+  rescue RubyLsp::SetupBundler::BundleNotLocked
+    warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
+    exit(78)
+  end
 
   env = { "BUNDLE_GEMFILE" => bundle_gemfile }
-  env["BUNDLE_PATH"] = File.expand_path(path, Dir.pwd) if path
+  env["BUNDLE_PATH"] = bundle_path if bundle_path
   exit exec(env, "bundle exec ruby-lsp #{ARGV.join(" ")}")
 end
 

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

@@ -4,6 +4,8 @@
 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
@@ -13,107 +15,142 @@ module RubyLsp
   class SetupBundler
     extend T::Sig
 
+    class BundleNotLocked < StandardError; end
+
     sig { params(project_path: String).void }
     def initialize(project_path)
       @project_path = project_path
-      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
-      @custom_bundle_dependencies = T.let(
-        if File.exist?(".ruby-lsp/Gemfile.lock")
-          Bundler::LockfileParser.new(Bundler.read_file(".ruby-lsp/Gemfile.lock")).dependencies
-        else
-          {}
+
+      # Custom bundle paths
+      @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(
+        begin
+          Bundler.default_gemfile
+        rescue Bundler::GemfileNotFound
+          nil
         end,
-        T::Hash[String, T.untyped],
+        T.nilable(Pathname),
       )
+      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
+
+      @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
     end
 
-    sig { void }
+    # Setups up the custom bundle and returns the `BUNDLE_GEMFILE` and `BUNDLE_PATH` that should be used for running the
+    # server
+    sig { returns([String, T.nilable(String)]) }
     def setup!
-      # Do not setup a custom bundle if we're working on the Ruby LSP, since it's already included by default
-      if File.basename(@project_path) == "ruby-lsp"
-        warn("Ruby LSP> Skipping custom bundle setup since we're working on the Ruby LSP itself")
-        run_bundle_install
-        return
-      end
+      raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
 
       # Do not setup a custom bundle if both `ruby-lsp` and `debug` are already in the Gemfile
       if @dependencies["ruby-lsp"] && @dependencies["debug"]
-        warn("Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in the Gemfile")
+        warn("Ruby LSP> Skipping custom bundle setup since both `ruby-lsp` and `debug` are already in #{@gemfile}")
 
         # If the user decided to add the `ruby-lsp` and `debug` to their Gemfile after having already run the Ruby LSP,
         # then we need to remove the `.ruby-lsp` folder, otherwise we will run `bundle install` for the top level and
         # try to execute the Ruby LSP using the custom bundle, which will fail since the gems are not installed there
-        FileUtils.rm_r(".ruby-lsp") if Dir.exist?(".ruby-lsp")
-        run_bundle_install
-        return
+        @custom_dir.rmtree if @custom_dir.exist?
+        return run_bundle_install
       end
 
       # Automatically create and ignore the .ruby-lsp folder for users
-      FileUtils.mkdir(".ruby-lsp") unless Dir.exist?(".ruby-lsp")
-      File.write(".ruby-lsp/.gitignore", "*") unless File.exist?(".ruby-lsp/.gitignore")
+      @custom_dir.mkpath unless @custom_dir.exist?
+      ignore_file = @custom_dir + ".gitignore"
+      ignore_file.write("*") unless ignore_file.exist?
 
-      # Write the custom `.ruby-lsp/Gemfile` if it doesn't exist or if the content doesn't match
-      content = custom_gemfile_content
+      write_custom_gemfile
 
-      unless File.exist?(".ruby-lsp/Gemfile") && File.read(".ruby-lsp/Gemfile") == content
-        File.write(".ruby-lsp/Gemfile", content)
+      unless @gemfile&.exist? && @lockfile&.exist?
+        warn("Ruby LSP> Skipping lockfile copies because there's no top level bundle")
+        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 File.exist?(".ruby-lsp/Gemfile.lock") &&
-          File.stat(".ruby-lsp/Gemfile.lock").mtime > File.stat("Gemfile.lock").mtime
-        warn("Ruby LSP> Skipping custom bundle setup since .ruby-lsp/Gemfile.lock already exists and is up to date")
-        run_bundle_install(".ruby-lsp/Gemfile")
-        return
+      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("Gemfile.lock", ".ruby-lsp/Gemfile.lock")
-      run_bundle_install(".ruby-lsp/Gemfile")
+      FileUtils.cp(@lockfile.to_s, @custom_lockfile.to_s)
+      @lockfile_hash_path.write(current_lockfile_hash)
+      run_bundle_install(@custom_gemfile)
     end
 
     private
 
-    sig { returns(String) }
-    def custom_gemfile_content
+    sig { returns(T::Hash[String, T.untyped]) }
+    def custom_bundle_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
+
+    sig { void }
+    def write_custom_gemfile
       parts = [
         "# This custom gemfile is automatically generated by the Ruby LSP.",
         "# It should be automatically git ignored, but in any case: do not commit it to your repository.",
         "",
-        "eval_gemfile(File.expand_path(\"../Gemfile\", __dir__))",
       ]
 
+      # If there's a top level Gemfile, we want to evaluate from the custom bundle. We get the source from the top level
+      # Gemfile, so if there isn't one we need to add a default source
+      if @gemfile&.exist?
+        parts << "eval_gemfile(File.expand_path(\"../Gemfile\", __dir__))"
+      else
+        parts.unshift('source "https://rubygems.org"')
+      end
+
       unless @dependencies["ruby-lsp"]
-        parts << 'gem "ruby-lsp", require: false, group: :development, source: "https://rubygems.org"'
+        parts << 'gem "ruby-lsp", require: false, group: :development'
       end
 
       unless @dependencies["debug"]
-        parts << 'gem "debug", require: false, group: :development, platforms: :mri, source: "https://rubygems.org"'
+        parts << 'gem "debug", require: false, group: :development, platforms: :mri'
       end
 
-      parts.join("\n")
+      content = parts.join("\n")
+      @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
     sig { returns(T::Hash[String, T.untyped]) }
     def load_dependencies
+      return {} unless @lockfile&.exist?
+
       # We need to parse the Gemfile.lock manually here. If we try to do `bundler/setup` to use something more
       # convenient, we may end up with issues when the globally installed `ruby-lsp` version mismatches the one included
       # in the `Gemfile`
-      dependencies = Bundler::LockfileParser.new(Bundler.read_file("Gemfile.lock")).dependencies
+      dependencies = Bundler::LockfileParser.new(@lockfile.read).dependencies
 
       # When working on a gem, the `ruby-lsp` might be listed as a dependency in the gemspec. We need to make sure we
-      # check those as well or else we may get version mismatch errors
-      gemspec_path = Dir.glob("*.gemspec").first
-      if gemspec_path
-        gemspec_dependencies = Bundler.load_gemspec(gemspec_path).dependencies.to_h { |dep| [dep.name, dep] }
-        dependencies.merge!(gemspec_dependencies)
+      # check those as well or else we may get version mismatch errors. Notice that bundler allows more than one
+      # gemspec, so we need to make sure we go through all of them
+      Dir.glob("{,*}.gemspec").each do |path|
+        dependencies.merge!(Bundler.load_gemspec(path).dependencies.to_h { |dep| [dep.name, dep] })
       end
 
       dependencies
     end
 
-    sig { params(bundle_gemfile: T.untyped).void }
-    def run_bundle_install(bundle_gemfile = nil)
+    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([String, T.nilable(String)]) }
+    def run_bundle_install(bundle_gemfile = @gemfile)
       # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
       # relative version of it when running `bundle install`. This is necessary to avoid installing the gems under the
       # `.ruby-lsp` folder, which is not the user's intention. For example, if the path is configured as `vendor`, we
@@ -122,7 +159,7 @@ module RubyLsp
 
       # Use the absolute `BUNDLE_PATH` to prevent accidentally creating unwanted folders under `.ruby-lsp`
       env = {}
-      env["BUNDLE_GEMFILE"] = bundle_gemfile if bundle_gemfile
+      env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
       env["BUNDLE_PATH"] = File.expand_path(path, Dir.pwd) if path
 
       # If both `ruby-lsp` and `debug` are already in the Gemfile, then we shouldn't try to upgrade them or else we'll
@@ -133,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
@@ -150,6 +187,7 @@ module RubyLsp
       # Add bundle update
       warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
       system(env, command)
+      [bundle_gemfile.to_s, path]
     end
   end
 end

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.5
+  version: 0.8.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-01 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
@@ -140,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.16
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby