ruby-lsp 0.23.11 → 0.26.5

data/lib/ruby_lsp/setup_bundler.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "bundler"
 require "bundler/cli"
 require "bundler/cli/install"
@@ -12,63 +11,66 @@ require "digest"
 require "time"
 require "uri"
 
-# This file is a script that will configure a composed bundle for the Ruby LSP. The composed 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
-# exact locked versions of dependencies.
+# This file is a script that will configure a composed bundle for the Ruby LSP. The composed 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 exact locked versions of dependencies.
 
 Bundler.ui.level = :silent
 
 module RubyLsp
   class SetupBundler
-    extend T::Sig
-
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
-    FOUR_HOURS = T.let(4 * 60 * 60, Integer)
+    module ThorPatch
+      #: -> IO
+      def stdout
+        $stderr
+      end
+    end
+
+    FOUR_HOURS = 4 * 60 * 60 #: Integer
 
-    sig { params(project_path: String, options: T.untyped).void }
+    #: (String project_path, **untyped options) -> void
     def initialize(project_path, **options)
       @project_path = project_path
-      @branch = T.let(options[:branch], T.nilable(String))
-      @launcher = T.let(options[:launcher], T.nilable(T::Boolean))
-      patch_thor_to_print_progress_to_stderr! if @launcher
+      @branch = options[:branch] #: String?
+      @launcher = options[:launcher] #: bool?
+      force_output_to_stderr! if @launcher
 
       # Regular bundle paths
-      @gemfile = T.let(
-        begin
-          Bundler.default_gemfile
-        rescue Bundler::GemfileNotFound
-          nil
-        end,
-        T.nilable(Pathname),
-      )
-      @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(Pathname))
+      @gemfile = begin
+        Bundler.default_gemfile
+      rescue Bundler::GemfileNotFound
+        nil
+      end #: Pathname?
+      @lockfile = @gemfile ? Bundler.default_lockfile : nil #: Pathname?
 
-      @gemfile_hash = T.let(@gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil, T.nilable(String))
-      @lockfile_hash = T.let(@lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil, T.nilable(String))
+      @gemfile_hash = @gemfile ? Digest::SHA256.hexdigest(@gemfile.read) : nil #: String?
+      @lockfile_hash = @lockfile&.exist? ? Digest::SHA256.hexdigest(@lockfile.read) : nil #: String?
 
-      @gemfile_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
+      @gemfile_name = @gemfile&.basename&.to_s || "Gemfile" #: String
 
       # Custom bundle paths
-      @custom_dir = T.let(Pathname.new(".ruby-lsp").expand_path(@project_path), Pathname)
-      @custom_gemfile = T.let(@custom_dir + @gemfile_name, Pathname)
-      @custom_lockfile = T.let(@custom_dir + (@lockfile&.basename || "Gemfile.lock"), Pathname)
-      @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
-      @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
-      @error_path = T.let(@custom_dir + "install_error", Pathname)
-      @already_composed_path = T.let(@custom_dir + "bundle_is_composed", Pathname)
+      @custom_dir = Pathname.new(".ruby-lsp").expand_path(@project_path) #: Pathname
+      @custom_gemfile = @custom_dir + @gemfile_name #: Pathname
+      @custom_lockfile = @custom_dir + (@lockfile&.basename || "Gemfile.lock") #: Pathname
+      @lockfile_hash_path = @custom_dir + "main_lockfile_hash" #: Pathname
+      @last_updated_path = @custom_dir + "last_updated" #: Pathname
+      @error_path = @custom_dir + "install_error" #: Pathname
+      @already_composed_path = @custom_dir + "bundle_is_composed" #: Pathname
 
       dependencies, bundler_version = load_dependencies
-      @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
-      @bundler_version = T.let(bundler_version, T.nilable(Gem::Version))
-      @rails_app = T.let(rails_app?, T::Boolean)
-      @retry = T.let(false, T::Boolean)
+      @dependencies = dependencies #: Hash[String, untyped]
+      @bundler_version = bundler_version #: Gem::Version?
+      @rails_app = rails_app? #: bool
+      @retry = false #: bool
+      @needs_update_path = @custom_dir + "needs_update" #: Pathname
     end
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
     # used for running the server
-    sig { returns(T::Hash[String, String]) }
+    #: -> Hash[String, String]
     def setup!
       raise BundleNotLocked if !@launcher && @gemfile&.exist? && !@lockfile&.exist?
 
@@ -128,26 +130,23 @@ module RubyLsp
 
     private
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    #: -> Hash[String, untyped]
     def composed_bundle_dependencies
-      @composed_bundle_dependencies ||= T.let(
-        begin
-          original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
-
-          if @custom_lockfile.exist?
-            ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
-            Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
-          else
-            {}
-          end
-        ensure
-          ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
-        end,
-        T.nilable(T::Hash[String, T.untyped]),
-      )
+      @composed_bundle_dependencies ||= begin
+        original_bundle_gemfile = ENV["BUNDLE_GEMFILE"]
+
+        if @custom_lockfile.exist?
+          ENV["BUNDLE_GEMFILE"] = @custom_gemfile.to_s
+          Bundler::LockfileParser.new(@custom_lockfile.read).dependencies
+        else
+          {}
+        end
+      ensure
+        ENV["BUNDLE_GEMFILE"] = original_bundle_gemfile
+      end #: Hash[String, untyped]?
     end
 
-    sig { void }
+    #: -> void
     def write_custom_gemfile
       parts = [
         "# This custom gemfile is automatically generated by the Ruby LSP.",
@@ -188,7 +187,7 @@ module RubyLsp
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
-    sig { returns([T::Hash[String, T.untyped], T.nilable(Gem::Version)]) }
+    #: -> [Hash[String, untyped], Gem::Version?]
     def load_dependencies
       return [{}, nil] unless @lockfile&.exist?
 
@@ -208,7 +207,7 @@ module RubyLsp
       [dependencies, lockfile_parser.bundler_version]
     end
 
-    sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
+    #: (?Pathname? bundle_gemfile) -> Hash[String, String]
     def run_bundle_install(bundle_gemfile = @gemfile)
       env = bundler_settings_as_env
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
@@ -235,6 +234,15 @@ module RubyLsp
         # If no error occurred, then clear previous errors
         @error_path.delete if @error_path.exist?
         $stderr.puts("Ruby LSP> Composed bundle installation complete")
+      rescue Errno::EPIPE, Bundler::HTTPError
+        # There are cases where we expect certain errors to happen occasionally, and we don't want to write them to
+        # a file, which would report to telemetry on the next launch.
+        #
+        # - The $stderr pipe might be closed by the client, for example when closing the editor during running bundle
+        # install. This situation may happen because, while running bundle install, the server is not yet ready to
+        # receive shutdown requests and we may continue doing work until the process is killed.
+        # - Bundler might also encounter a network error.
+        @error_path.delete if @error_path.exist?
       rescue => e
         # Write the error object to a file so that we can read it from the parent process
         @error_path.write(Marshal.dump(e))
@@ -259,21 +267,68 @@ module RubyLsp
       env
     end
 
-    sig { params(env: T::Hash[String, String], force_install: T::Boolean).returns(T::Hash[String, String]) }
+    #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      # The ENV can only be merged after checking if an update is required because we depend on the original value of
-      # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
-      should_update = should_bundle_update?
-      T.unsafe(ENV).merge!(env)
+      # The should_bundle_update? check needs to run on the original Bundler environment, but everything else (like
+      # updating or running install) requires the modified environment. Here we compute the check ahead of time and
+      # merge the environment to ensure correct results.
+      #
+      # The symptoms of having these operations in the wrong order is seeing unwanted modifications in the application's
+      # main lockfile because we accidentally run update on the main bundle instead of the composed one.
+      needs_update = should_bundle_update?
+      ENV.merge!(env)
+
+      return update(env) if @needs_update_path.exist?
+
+      FileUtils.touch(@needs_update_path) if needs_update
+
+      $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
 
-      unless should_update && !force_install
-        Bundler::CLI::Install.new({}).run
-        correct_relative_remote_paths if @custom_lockfile.exist?
+      begin
+        missing_gems = bundle_check
+      rescue Errno::EPIPE, Bundler::HTTPError
+        # These are errors cases where we cannot recover
+        raise
+      rescue => e
+        # If anything fails with bundle check, try to bundle install
+        $stderr.puts("Ruby LSP> Running bundle install because #{e.message}")
+        bundle_install
         return env
       end
 
+      if missing_gems.empty?
+        $stderr.puts("Ruby LSP> Bundle already satisfied")
+      else
+        $stderr.puts(<<~MESSAGE)
+          Ruby LSP> Running bundle install because the following gems are not installed:
+          #{missing_gems.map { |g| "#{g.name}: #{g.version}" }.join("\n")}
+        MESSAGE
+
+        bundle_install
+      end
+
+      env
+    end
+
+    # Essentially the same as bundle check, but simplified
+    #: -> Array[Gem::Specification]
+    def bundle_check
+      definition = Bundler.definition
+      definition.validate_runtime!
+      definition.check!
+      definition.missing_specs
+    end
+
+    #: -> void
+    def bundle_install
+      Bundler::CLI::Install.new({ "no-cache" => true }).run
+      correct_relative_remote_paths if @custom_lockfile.exist?
+    end
+
+    #: (Hash[String, String]) -> Hash[String, String]
+    def update(env)
       # Try to auto upgrade the gems we depend on, unless they are in the Gemfile as that would result in undesired
       # source control changes
       gems = ["ruby-lsp", "debug", "prism"].reject { |dep| @dependencies[dep] }
@@ -281,14 +336,12 @@ module RubyLsp
 
       Bundler::CLI::Update.new({ conservative: true }, gems).run
       correct_relative_remote_paths if @custom_lockfile.exist?
+      @needs_update_path.delete
       @last_updated_path.write(Time.now.iso8601)
       env
-    rescue Bundler::GemNotFound, Bundler::GitError
-      # If a gem is not installed, skip the upgrade and try to install it with a single retry
-      @retry ? env : run_bundle_install_directly(env, force_install: true)
     end
 
-    sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
+    #: (Hash[String, String] env) -> Hash[String, String]
     def run_bundle_install_through_command(env)
       # If `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) are already in the Gemfile, then we shouldn't try
       # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
@@ -345,7 +398,7 @@ module RubyLsp
     end
 
     # Gather all Bundler settings (global and local) and return them as a hash that can be used as the environment
-    sig { returns(T::Hash[String, String]) }
+    #: -> Hash[String, String]
     def bundler_settings_as_env
       local_config_path = File.join(@project_path, ".bundle")
 
@@ -357,10 +410,17 @@ module RubyLsp
         Bundler::Settings.new
       end
 
+      # List of Bundler settings that don't make sense for the composed bundle and are better controlled manually by the
+      # user
+      ignored_settings = ["bin", "cache_all", "cache_all_platforms"]
+
       # Map all settings to their environment variable names with `key_for` and their values. For example, the if the
       # setting name `e` is `path` with a value of `vendor/bundle`, then it will return `"BUNDLE_PATH" =>
       # "vendor/bundle"`
-      settings.all.to_h do |e|
+      settings
+        .all
+        .reject { |setting| ignored_settings.include?(setting) }
+        .to_h do |e|
         key = settings.key_for(e)
         value = Array(settings[e]).join(":").tr(" ", ":")
 
@@ -368,7 +428,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def install_bundler_if_needed
       # Try to find the bundler version specified in the lockfile in installed gems. If not found, install it
       requirement = Gem::Requirement.new(@bundler_version.to_s)
@@ -377,7 +437,7 @@ module RubyLsp
       Gem.install("bundler", @bundler_version.to_s)
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def should_bundle_update?
       # If `ruby-lsp`, `ruby-lsp-rails` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it
       # will produce version control changes
@@ -400,16 +460,19 @@ module RubyLsp
 
     # When a lockfile has remote references based on relative file paths, we need to ensure that they are pointing to
     # the correct place since after copying the relative path is no longer valid
-    sig { void }
+    #: -> void
     def correct_relative_remote_paths
       content = @custom_lockfile.read
       content.gsub!(/remote: (.*)/) do |match|
-        path = T.must(Regexp.last_match)[1]
+        last_match = Regexp.last_match #: as !nil
+        path = last_match[1]
 
         # We should only apply the correction if the remote is a relative path. It might also be a URI, like
         # `https://rubygems.org` or an absolute path, in which case we shouldn't do anything
         if path && !URI(path).scheme
-          "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
+          bundle_dir = @gemfile #: as !nil
+            .dirname
+          "remote: #{File.expand_path(path, bundle_dir)}"
         else
           match
         end
@@ -422,7 +485,7 @@ module RubyLsp
     end
 
     # Detects if the project is a Rails app by looking if the superclass of the main class is `Rails::Application`
-    sig { returns(T::Boolean) }
+    #: -> bool
     def rails_app?
       config = Pathname.new("config/application.rb").expand_path
       application_contents = config.read(external_encoding: Encoding::UTF_8) if config.exist?
@@ -431,20 +494,17 @@ module RubyLsp
       /class .* < (::)?Rails::Application/.match?(application_contents)
     end
 
-    sig { void }
-    def patch_thor_to_print_progress_to_stderr!
-      return unless defined?(Bundler::Thor::Shell::Basic)
-
-      Bundler::Thor::Shell::Basic.prepend(Module.new do
-        extend T::Sig
+    #: -> void
+    def force_output_to_stderr!
+      # Bundler and RubyGems have different UI objects used for printing. We need to ensure that both are configured to
+      # print only to stderr or else they'll break the connection with the editor
+      Gem::DefaultUserInteraction.ui = Gem::StreamUI.new($stdin, $stderr, $stderr, false)
 
-        sig { returns(IO) }
-        def stdout
-          $stderr
-        end
-      end)
+      ui = Bundler.ui
+      ui.output_stream = :stderr if ui.respond_to?(:output_stream=)
+      ui.level = :info
 
-      Bundler.ui.level = :info
+      Bundler::Thor::Shell::Basic.prepend(ThorPatch) if defined?(Bundler::Thor::Shell::Basic)
     end
   end
 end

data/lib/ruby_lsp/static_docs.rb

@@ -3,13 +3,18 @@
 
 module RubyLsp
   # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = T.let(File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs"), String)
+  STATIC_DOCS_PATH = File.join(
+    File.dirname(
+      File.dirname(
+        __dir__, #: as !nil
+      ),
+    ),
+    "static_docs",
+  ) #: String
 
   # A map of keyword => short documentation to be displayed on hover or completion
-  KEYWORD_DOCS = T.let(
-    {
-      "yield" => "Invokes the passed block with the given arguments",
-    }.freeze,
-    T::Hash[String, String],
-  )
+  KEYWORD_DOCS = {
+    "break" => "Terminates the execution of a block or loop",
+    "yield" => "Invokes the passed block with the given arguments",
+  }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -3,34 +3,19 @@
 
 module RubyLsp
   class Store
-    extend T::Sig
-
     class NonExistingDocumentError < StandardError; end
 
-    sig { returns(T::Hash[Symbol, RequestConfig]) }
-    attr_accessor :features_configuration
-
-    sig { returns(String) }
+    #: String
     attr_accessor :client_name
 
-    sig { params(global_state: GlobalState).void }
+    #: (GlobalState global_state) -> void
     def initialize(global_state)
       @global_state = global_state
-      @state = T.let({}, T::Hash[String, Document[T.untyped]])
-      @features_configuration = T.let(
-        {
-          inlayHint: RequestConfig.new({
-            enableAll: false,
-            implicitRescue: false,
-            implicitHashValue: false,
-          }),
-        },
-        T::Hash[Symbol, RequestConfig],
-      )
-      @client_name = T.let("Unknown", String)
+      @state = {} #: Hash[String, Document[untyped]]
+      @client_name = "Unknown" #: String
     end
 
-    sig { params(uri: URI::Generic).returns(Document[T.untyped]) }
+    #: (URI::Generic uri) -> Document[untyped]
     def get(uri)
       document = @state[uri.to_s]
       return document unless document.nil?
@@ -43,78 +28,65 @@ 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)
-      T.must(@state[uri.to_s])
+      @state[uri.to_s] #: as !nil
     rescue Errno::ENOENT
       raise NonExistingDocumentError, uri.to_s
     end
 
-    sig do
-      params(
-        uri: URI::Generic,
-        source: String,
-        version: Integer,
-        language_id: Document::LanguageId,
-      ).returns(Document[T.untyped])
-    end
+    #: (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)
       end
     end
 
-    sig { params(uri: URI::Generic, edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
+    #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
     def push_edits(uri:, edits:, version:)
-      T.must(@state[uri.to_s]).push_edits(edits, version: version)
+      @state[uri.to_s] #: as !nil
+        .push_edits(edits, version: version)
     end
 
-    sig { void }
+    #: -> void
     def clear
       @state.clear
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def empty?
       @state.empty?
     end
 
-    sig { params(uri: URI::Generic).void }
+    #: (URI::Generic uri) -> void
     def delete(uri)
       @state.delete(uri.to_s)
     end
 
-    sig { params(uri: URI::Generic).returns(T::Boolean) }
+    #: (URI::Generic uri) -> bool
     def key?(uri)
       @state.key?(uri.to_s)
     end
 
-    sig { params(block: T.proc.params(uri: String, document: Document[T.untyped]).void).void }
+    #: { (String uri, Document[untyped] document) -> void } -> void
     def each(&block)
       @state.each do |uri, document|
         block.call(uri, document)
       end
     end
 
-    sig do
-      type_parameters(:T)
-        .params(
-          uri: URI::Generic,
-          request_name: String,
-          block: T.proc.params(document: Document[T.untyped]).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (URI::Generic uri, String request_name) { (Document[untyped] document) -> T } -> T
     def cache_fetch(uri, request_name, &block)
       get(uri).cache_fetch(request_name, &block)
     end

data/lib/ruby_lsp/test_helper.rb

@@ -4,24 +4,11 @@
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
+  # @requires_ancestor: Kernel
   module TestHelper
     class TestError < StandardError; end
 
-    extend T::Sig
-    extend T::Helpers
-
-    requires_ancestor { Kernel }
-
-    sig do
-      type_parameters(:T)
-        .params(
-          source: T.nilable(String),
-          uri: URI::Generic,
-          stub_no_typechecker: T::Boolean,
-          load_addons: T::Boolean,
-          block: T.proc.params(server: RubyLsp::Server, uri: URI::Generic).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (?String? source, ?URI::Generic uri, ?stub_no_typechecker: bool, ?load_addons: bool) { (RubyLsp::Server server, URI::Generic uri) -> T } -> T
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)
       server = RubyLsp::Server.new(test_mode: true)
@@ -58,7 +45,7 @@ module RubyLsp
       end
     end
 
-    sig { params(server: RubyLsp::Server).returns(RubyLsp::Result) }
+    #: (RubyLsp::Server server) -> RubyLsp::Result
     def pop_result(server)
       result = server.pop_response
       result = server.pop_response until result.is_a?(RubyLsp::Result) || result.is_a?(RubyLsp::Error)