ruby-lsp 0.23.16 → 0.23.18

data/lib/ruby_lsp/ruby_document.rb

@@ -2,11 +2,8 @@
 # frozen_string_literal: true
 
 module RubyLsp
+  #: [ParseResultType = Prism::ParseResult]
   class RubyDocument < Document
-    extend T::Generic
-
-    ParseResultType = type_member { { fixed: Prism::ParseResult } }
-
     METHODS_THAT_CHANGE_DECLARATIONS = [
       :private_constant,
       :attr_reader,
@@ -23,16 +20,6 @@ module RubyLsp
       :private_class_method,
     ].freeze
 
-    class SorbetLevel < T::Enum
-      enums do
-        None = new("none")
-        Ignore = new("ignore")
-        False = new("false")
-        True = new("true")
-        Strict = new("strict")
-      end
-    end
-
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
@@ -154,29 +141,9 @@ module RubyLsp
     end
 
     # @override
-    #: -> LanguageId
+    #: -> Symbol
     def language_id
-      LanguageId::Ruby
-    end
-
-    #: -> SorbetLevel
-    def sorbet_level
-      sigil = parse_result.magic_comments.find do |comment|
-        comment.key == "typed"
-      end&.value
-
-      case sigil
-      when "ignore"
-        SorbetLevel::Ignore
-      when "false"
-        SorbetLevel::False
-      when "true"
-        SorbetLevel::True
-      when "strict", "strong"
-        SorbetLevel::Strict
-      else
-        SorbetLevel::None
-      end
+      :ruby
     end
 
     #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?

data/lib/ruby_lsp/server.rb

@@ -32,6 +32,8 @@ module RubyLsp
         text_document_document_link(message)
       when "textDocument/codeLens"
         text_document_code_lens(message)
+      when "codeLens/resolve"
+        code_lens_resolve(message)
       when "textDocument/semanticTokens/full"
         text_document_semantic_tokens_full(message)
       when "textDocument/semanticTokens/full/delta"
@@ -242,7 +244,9 @@ module RubyLsp
 
       bundle_env_path = File.join(".ruby-lsp", "bundle_env")
       bundle_env = if File.exist?(bundle_env_path)
-        env = File.readlines(bundle_env_path).to_h { |line| T.cast(line.chomp.split("=", 2), [String, String]) }
+        env = File.readlines(bundle_env_path).to_h do |line|
+          line.chomp.split("=", 2) #: as [String, String]
+        end
         FileUtils.rm(bundle_env_path)
         env
       end
@@ -385,11 +389,11 @@ module RubyLsp
         text_document = message.dig(:params, :textDocument)
         language_id = case text_document[:languageId]
         when "erb", "eruby"
-          Document::LanguageId::ERB
+          :erb
         when "rbs"
-          Document::LanguageId::RBS
+          :rbs
         else
-          Document::LanguageId::Ruby
+          :ruby
         end
 
         document = @store.set(
@@ -489,13 +493,16 @@ module RubyLsp
       folding_range = Requests::FoldingRanges.new(parse_result.comments, dispatcher)
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
-      code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
       inlay_hint = Requests::InlayHints.new(
         document,
         @store.features_configuration.dig(:inlayHint), #: as !nil
         dispatcher,
       )
 
+      # The code lens listener requires the index to be populated, so the DeclarationListener must be inserted first in
+      # the dispatcher's state
+      code_lens = nil #: Requests::CodeLens?
+
       if document.is_a?(RubyDocument) && document.should_index?
         # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
         # updated on save
@@ -505,10 +512,12 @@ module RubyLsp
           @global_state.index.handle_change(uri) do |index|
             index.delete(uri, skip_require_paths_tree: true)
             RubyIndexer::DeclarationListener.new(index, dispatcher, parse_result, uri, collect_comments: true)
+            code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
             dispatcher.dispatch(parse_result.value)
           end
         end
       else
+        code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
         dispatcher.dispatch(parse_result.value)
       end
 
@@ -517,7 +526,11 @@ module RubyLsp
       document.cache_set("textDocument/foldingRange", folding_range.perform)
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
-      document.cache_set("textDocument/codeLens", code_lens.perform)
+      document.cache_set(
+        "textDocument/codeLens",
+        code_lens #: as !nil
+          .perform,
+      )
       document.cache_set("textDocument/inlayHint", inlay_hint.perform)
 
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))
@@ -672,6 +685,10 @@ module RubyLsp
         "Formatting error: #{error.message}",
         type: Constant::MessageType::ERROR,
       ))
+      send_message(Notification.window_log_message(
+        "Formatting failed with\r\n: #{error.full_message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -795,12 +812,16 @@ module RubyLsp
       )
     end
 
-    #: (Document[untyped] document) -> RubyDocument::SorbetLevel
+    #: (Document[untyped] document) -> SorbetLevel
     def sorbet_level(document)
-      return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
-      return RubyDocument::SorbetLevel::Ignore unless document.is_a?(RubyDocument)
+      return SorbetLevel.ignore unless document.is_a?(RubyDocument)
+      return SorbetLevel.ignore unless @global_state.has_type_checker
+
+      sigil = document.parse_result.magic_comments.find do |comment|
+        comment.key == "typed"
+      end&.value
 
-      document.sorbet_level
+      SorbetLevel.new(sigil)
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -871,17 +892,9 @@ module RubyLsp
       end
 
       result = Requests::CodeActionResolve.new(document, @global_state, params).perform
-
-      case result
-      when Requests::CodeActionResolve::Error::EmptySelection
-        fail_request_and_notify(message[:id], "Invalid selection for extract variable refactor")
-      when Requests::CodeActionResolve::Error::InvalidTargetRange
-        fail_request_and_notify(message[:id], "Couldn't find an appropriate location to place extracted refactor")
-      when Requests::CodeActionResolve::Error::UnknownCodeAction
-        fail_request_and_notify(message[:id], "Unknown code action")
-      else
-        send_message(Result.new(id: message[:id], response: result))
-      end
+      send_message(Result.new(id: message[:id], response: result))
+    rescue Requests::CodeActionResolve::CodeActionError => e
+      fail_request_and_notify(message[:id], e.message)
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -921,6 +934,10 @@ module RubyLsp
         "Error running diagnostics: #{error.message}",
         type: Constant::MessageType::ERROR,
       ))
+      send_message(Notification.window_log_message(
+        "Diagnostics failed with\r\n: #{error.full_message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -1109,7 +1126,7 @@ module RubyLsp
       # Clear all document caches for pull diagnostics
       @global_state.synchronize do
         @store.each do |_uri, document|
-          document.cache_set("textDocument/diagnostic", Document::EMPTY_CACHE)
+          document.clear_cache("textDocument/diagnostic")
         end
       end
 
@@ -1265,9 +1282,25 @@ module RubyLsp
         # allocations and garbage collections are faster
         GC.compact unless @test_mode
 
+        @global_state.synchronize do
+          # If we linearize ancestors while the index is not fully populated, we may end up caching incorrect results
+          # that were missing namespaces. After indexing is complete, we need to clear the ancestors cache and start
+          # again
+          @global_state.index.clear_ancestors
+
+          # The results for code lens depend on ancestor linearization, so we need to clear any previously computed
+          # responses
+          @store.each { |_uri, document| document.clear_cache("textDocument/codeLens") }
+        end
+
         # Always end the progress notification even if indexing failed or else it never goes away and the user has no
         # way of dismissing it
         end_progress("indexing-progress")
+
+        # Request a code lens refresh if we populated them before all test parent classes were indexed
+        if @global_state.client_capabilities.supports_code_lens_refresh
+          send_message(Request.new(id: @current_request_id, method: "workspace/codeLens/refresh", params: nil))
+        end
       end
     end
 
@@ -1482,5 +1515,26 @@ module RubyLsp
         },
       ))
     end
+
+    #: (Hash[Symbol, untyped] message) -> void
+    def code_lens_resolve(message)
+      code_lens = message[:params]
+      args = code_lens.dig(:data, :arguments)
+
+      case code_lens.dig(:data, :kind)
+      when "run_test"
+        code_lens[:command] = Interface::Command.new(title: "▶ Run", command: "rubyLsp.runTest", arguments: args)
+      when "run_test_in_terminal"
+        code_lens[:command] =
+          Interface::Command.new(title: "▶ Run in terminal", command: "rubyLsp.runTestInTerminal", arguments: args)
+      when "debug_test"
+        code_lens[:command] = Interface::Command.new(title: "⚙ Debug", command: "rubyLsp.debugTest", arguments: args)
+      end
+
+      send_message(Result.new(
+        id: message[:id],
+        response: code_lens,
+      ))
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -38,11 +38,11 @@ module RubyLsp
       ext = File.extname(path)
       language_id = case ext
       when ".erb", ".rhtml"
-        Document::LanguageId::ERB
+        :erb
       when ".rbs"
-        Document::LanguageId::RBS
+        :rbs
       else
-        Document::LanguageId::Ruby
+        :ruby
       end
 
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
@@ -51,12 +51,12 @@ module RubyLsp
       raise NonExistingDocumentError, uri.to_s
     end
 
-    #: (uri: URI::Generic, source: String, version: Integer, language_id: Document::LanguageId) -> Document[untyped]
+    #: (uri: URI::Generic, source: String, version: Integer, language_id: Symbol) -> Document[untyped]
     def set(uri:, source:, version:, language_id:)
       @state[uri.to_s] = case language_id
-      when Document::LanguageId::ERB
+      when :erb
         ERBDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
-      when Document::LanguageId::RBS
+      when :rbs
         RBSDocument.new(source: source, version: version, uri: uri, global_state: @global_state)
       else
         RubyDocument.new(source: source, version: version, uri: uri, global_state: @global_state)

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -4,21 +4,40 @@
 require "json"
 require "socket"
 require "singleton"
+require "tmpdir"
 
 module RubyLsp
   class LspReporter
     include Singleton
 
+    #: bool
+    attr_reader :invoked_shutdown
+
     #: -> void
     def initialize
+      dir_path = File.join(Dir.tmpdir, "ruby-lsp")
+      FileUtils.mkdir_p(dir_path)
+
+      port_path = File.join(dir_path, "test_reporter_port")
       port = ENV["RUBY_LSP_REPORTER_PORT"]
-      @io = if port
-        TCPSocket.new("localhost", port)
-      else
-        # For tests that don't spawn the TCP server
+
+      @io = begin
+        # The environment variable is only used for tests. The extension always writes to the temporary file
+        if port
+          TCPSocket.new("localhost", port)
+        elsif File.exist?(port_path)
+          TCPSocket.new("localhost", File.read(port_path))
+        else
+          # For tests that don't spawn the TCP server
+          require "stringio"
+          StringIO.new
+        end
+      rescue
         require "stringio"
         StringIO.new
       end #: IO | StringIO
+
+      @invoked_shutdown = false #: bool
     end
 
     #: -> void
@@ -34,13 +53,15 @@ module RubyLsp
     # reporter, use `shutdown` instead
     #: -> void
     def internal_shutdown
+      @invoked_shutdown = true
+
       send_message("finish")
       @io.close
     end
 
-    #: (id: String, uri: URI::Generic) -> void
-    def start_test(id:, uri:)
-      send_message("start", id: id, uri: uri.to_s)
+    #: (id: String, uri: URI::Generic, ?line: Integer?) -> void
+    def start_test(id:, uri:, line: nil)
+      send_message("start", id: id, uri: uri.to_s, line: line)
     end
 
     #: (id: String, uri: URI::Generic) -> void
@@ -63,6 +84,17 @@ module RubyLsp
       send_message("error", id: id, message: message, uri: uri.to_s)
     end
 
+    #: (Method | UnboundMethod) -> [URI::Generic, Integer?]?
+    def uri_and_line_for(method_object)
+      file_path, line = method_object.source_location
+      return unless file_path
+      return if file_path.start_with?("(eval at ")
+
+      uri = URI::Generic.from_path(path: File.expand_path(file_path))
+      zero_based_line = line ? line - 1 : nil
+      [uri, zero_based_line]
+    end
+
     # Gather the results returned by Coverage.result and format like the VS Code test explorer expects
     #
     # Coverage result format:
@@ -94,10 +126,9 @@ module RubyLsp
     def gather_coverage_results
       # Ignore coverage results inside dependencies
       bundle_path = Bundler.bundle_path.to_s
-      default_gems_path = File.dirname(RbConfig::CONFIG["rubylibdir"])
 
       result = Coverage.result.reject do |file_path, _coverage_info|
-        file_path.start_with?(bundle_path, default_gems_path, "eval")
+        file_path.start_with?(bundle_path) || !file_path.start_with?(Dir.pwd)
       end
 
       result.to_h do |file_path, coverage_info|
@@ -142,7 +173,7 @@ module RubyLsp
 
     private
 
-    #: (method_name: String?, params: untyped) -> void
+    #: (String?, **untyped) -> void
     def send_message(method_name, **params)
       json_message = { method: method_name, params: params }.to_json
       @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
@@ -161,4 +192,10 @@ if ENV["RUBY_LSP_TEST_RUNNER"] == "coverage"
     File.write(File.join(".ruby-lsp", "coverage_result.json"), coverage_results.to_json)
     RubyLsp::LspReporter.instance.internal_shutdown
   end
+elsif ENV["RUBY_LSP_TEST_RUNNER"] && ENV["RUBY_LSP_ENV"] != "test"
+  at_exit do
+    # If the test process crashed immediately without finishing the tests, we still need to tell the extension that the
+    # execution ended so that it can clean up
+    RubyLsp::LspReporter.instance.internal_shutdown unless RubyLsp::LspReporter.instance.invoked_shutdown
+  end
 end

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -51,16 +51,19 @@ module RubyLsp
 
     #: (singleton(Minitest::Test) test_class, String method_name) -> void
     def prerecord(test_class, method_name)
-      uri = uri_from_test_class(test_class, method_name)
+      uri, line = LspReporter.instance.uri_and_line_for(test_class.instance_method(method_name))
       return unless uri
 
-      LspReporter.instance.start_test(id: "#{test_class.name}##{method_name}", uri: uri)
+      LspReporter.instance.start_test(id: "#{test_class.name}##{method_name}", uri: uri, line: line)
     end
 
     #: (Minitest::Result result) -> void
     def record(result)
       id = "#{result.klass}##{result.name}"
-      uri = uri_from_result(result)
+      file_path, _line = result.source_location
+      return unless file_path
+
+      uri = URI::Generic.from_path(path: File.expand_path(file_path))
 
       if result.error?
         message = result.failures.first.message
@@ -79,26 +82,6 @@ module RubyLsp
     def report
       LspReporter.instance.shutdown
     end
-
-    private
-
-    #: (Minitest::Result result) -> URI::Generic
-    def uri_from_result(result)
-      file = result.source_location[0]
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
-    end
-
-    #: (singleton(Minitest::Test) test_class, String method_name) -> URI::Generic?
-    def uri_from_test_class(test_class, method_name)
-      file, _line = test_class.instance_method(method_name).source_location
-      return unless file
-
-      return if file.start_with?("(eval at ") # test is dynamically defined
-
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
-    end
   end
 end
 

data/lib/ruby_lsp/test_reporters/test_unit_reporter.rb

@@ -26,12 +26,12 @@ module RubyLsp
     def test_started(test)
       super
 
-      current_test = test
-      @current_uri = uri_for_test(current_test)
-      return unless @current_uri
+      uri, line = LspReporter.instance.uri_and_line_for(test.method(test.method_name))
+      return unless uri
 
-      @current_test_id = "#{current_test.class.name}##{current_test.method_name}"
-      LspReporter.instance.start_test(id: @current_test_id, uri: @current_uri)
+      @current_uri = uri
+      @current_test_id = "#{test.class.name}##{test.method_name}"
+      LspReporter.instance.start_test(id: @current_test_id, uri: @current_uri, line: line)
     end
 
     #: (::Test::Unit::TestCase test) -> void
@@ -62,18 +62,6 @@ module RubyLsp
       LspReporter.instance.shutdown
     end
 
-    #: (::Test::Unit::TestCase test) -> URI::Generic?
-    def uri_for_test(test)
-      location = test.method(test.method_name).source_location
-      return unless location
-
-      file, _line = location
-      return if file.start_with?("(eval at ")
-
-      absolute_path = File.expand_path(file, Dir.pwd)
-      URI::Generic.from_path(path: absolute_path)
-    end
-
     #: -> void
     def attach_to_mediator
       # Events we care about

data/lib/ruby_lsp/utils.rb

@@ -259,4 +259,47 @@ module RubyLsp
       @configuration[:enableAll] || @configuration[feature]
     end
   end
+
+  class SorbetLevel
+    class << self
+      #: -> SorbetLevel
+      def ignore
+        new("ignore")
+      end
+    end
+
+    #: (String?) -> void
+    def initialize(sigil)
+      @level = case sigil
+      when "ignore"
+        :ignore
+      when "false"
+        :false
+      when "true"
+        :true
+      when "strict", "strong"
+        :strict
+      else
+        :none
+      end #: Symbol
+    end
+
+    #: -> bool
+    def ignore? = @level == :ignore
+
+    #: -> bool
+    def false? = @level == :false
+
+    #: -> bool
+    def true? = @level == :true
+
+    #: -> bool
+    def strict? = @level == :strict
+
+    #: -> bool
+    def none? = @level == :none
+
+    #: -> bool
+    def true_or_higher? = @level == :true || @level == :strict
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.16
+  version: 0.23.18
 platform: ruby
 authors:
 - Shopify