ruby-lsp 0.20.1 → 0.22.1

data/lib/ruby_lsp/setup_bundler.rb

@@ -3,12 +3,16 @@
 
 require "sorbet-runtime"
 require "bundler"
+require "bundler/cli"
+require "bundler/cli/install"
+require "bundler/cli/update"
 require "fileutils"
 require "pathname"
 require "digest"
 require "time"
+require "uri"
 
-# This file is a script that will configure a custom bundle for the Ruby LSP. The custom bundle allows developers to use
+# 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.
 
@@ -27,6 +31,8 @@ module RubyLsp
     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
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -39,6 +45,9 @@ module RubyLsp
       )
       @lockfile = T.let(@gemfile ? Bundler.default_lockfile : nil, T.nilable(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_name = T.let(@gemfile&.basename&.to_s || "Gemfile", String)
 
       # Custom bundle paths
@@ -47,6 +56,7 @@ module RubyLsp
       @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)
 
       dependencies, bundler_version = load_dependencies
       @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
@@ -55,33 +65,28 @@ module RubyLsp
       @retry = T.let(false, T::Boolean)
     end
 
-    # Sets up the custom bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
+    # 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]) }
     def setup!
-      raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
+      raise BundleNotLocked if !@launcher && @gemfile&.exist? && !@lockfile&.exist?
 
-      # Do not set up a custom bundle if LSP dependencies are already in the Gemfile
+      # Automatically create and ignore the .ruby-lsp folder for users
+      @custom_dir.mkpath unless @custom_dir.exist?
+      ignore_file = @custom_dir + ".gitignore"
+      ignore_file.write("*") unless ignore_file.exist?
+
+      # Do not set up a composed bundle if LSP dependencies are already in the Gemfile
       if @dependencies["ruby-lsp"] &&
           @dependencies["debug"] &&
           (@rails_app ? @dependencies["ruby-lsp-rails"] : true)
         $stderr.puts(
-          "Ruby LSP> Skipping custom bundle setup since LSP dependencies are already in #{@gemfile}",
+          "Ruby LSP> Skipping composed bundle setup since LSP dependencies are already in #{@gemfile}",
         )
 
-        # If the user decided to add `ruby-lsp` and `debug` (and potentially `ruby-lsp-rails`) 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
-        @custom_dir.rmtree if @custom_dir.exist?
         return run_bundle_install
       end
 
-      # Automatically create and ignore the .ruby-lsp folder for users
-      @custom_dir.mkpath unless @custom_dir.exist?
-      ignore_file = @custom_dir + ".gitignore"
-      ignore_file.write("*") unless ignore_file.exist?
-
       write_custom_gemfile
 
       unless @gemfile&.exist? && @lockfile&.exist?
@@ -89,39 +94,39 @@ module RubyLsp
         return run_bundle_install(@custom_gemfile)
       end
 
-      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
+      if @lockfile_hash && @custom_lockfile.exist? && @lockfile_hash_path.exist? &&
+          @lockfile_hash_path.read == @lockfile_hash
         $stderr.puts(
-          "Ruby LSP> Skipping custom bundle setup since #{@custom_lockfile} already exists and is up to date",
+          "Ruby LSP> Skipping composed 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)
       correct_relative_remote_paths
-      @lockfile_hash_path.write(current_lockfile_hash)
+      @lockfile_hash_path.write(@lockfile_hash)
       run_bundle_install(@custom_gemfile)
     end
 
     private
 
     sig { returns(T::Hash[String, T.untyped]) }
-    def custom_bundle_dependencies
-      @custom_bundle_dependencies ||= T.let(
+    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]),
       )
-    ensure
-      ENV.delete("BUNDLE_GEMFILE")
     end
 
     sig { void }
@@ -132,9 +137,9 @@ module RubyLsp
         "",
       ]
 
-      # 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?
+      # If there's a top level Gemfile, we want to evaluate from the composed 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? && @lockfile&.exist?
         parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
       else
         parts.unshift('source "https://rubygems.org"')
@@ -183,7 +188,7 @@ module RubyLsp
       env = bundler_settings_as_env
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
 
-      # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
+      # If the user has a composed 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
       # want to install it in the top level `vendor` and not `.ruby-lsp/vendor`
@@ -191,18 +196,73 @@ module RubyLsp
         env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
       end
 
-      # If there's a Bundler version locked, then we need to use that one to run bundle commands, so that the composed
-      # lockfile is also locked to the same version. This avoids Bundler restarts on version mismatches
-      base_bundle = if @bundler_version
+      return run_bundle_install_through_command(env) unless @launcher
+
+      # This same check happens conditionally when running through the command. For invoking the CLI directly, it's
+      # important that we ensure the Bundler version is set to avoid restarts
+      if @bundler_version
         env["BUNDLER_VERSION"] = @bundler_version.to_s
         install_bundler_if_needed
-        "bundle _#{@bundler_version}_"
-      else
-        "bundle"
       end
 
+      begin
+        run_bundle_install_directly(env)
+        # If no error occurred, then clear previous errors
+        @error_path.delete if @error_path.exist?
+        $stderr.puts("Ruby LSP> Composed bundle installation complete")
+      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))
+      end
+
+      # If either the Gemfile or the lockfile have been modified during the process of setting up the bundle, retry
+      # composing the bundle from scratch
+
+      if @gemfile && @lockfile
+        current_gemfile_hash = Digest::SHA256.hexdigest(@gemfile.read)
+        current_lockfile_hash = Digest::SHA256.hexdigest(@lockfile.read)
+
+        if !@retry && (current_gemfile_hash != @gemfile_hash || current_lockfile_hash != @lockfile_hash)
+          @gemfile_hash = current_gemfile_hash
+          @lockfile_hash = current_lockfile_hash
+          @retry = true
+          @custom_dir.rmtree
+          $stderr.puts("Ruby LSP> Bundle was modified during setup. Retrying from scratch...")
+          return setup!
+        end
+      end
+
+      env
+    end
+
+    sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
+    def run_bundle_install_directly(env)
+      RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+      T.unsafe(ENV).merge!(env)
+
+      unless should_bundle_update?
+        Bundler::CLI::Install.new({}).run
+        correct_relative_remote_paths if @custom_lockfile.exist?
+        return env
+      end
+
+      # 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] }
+      gems << "ruby-lsp-rails" if @rails_app && !@dependencies["ruby-lsp-rails"]
+
+      Bundler::CLI::Update.new({ conservative: true }, gems).run
+      correct_relative_remote_paths if @custom_lockfile.exist?
+      @last_updated_path.write(Time.now.iso8601)
+      env
+    end
+
+    sig { params(env: T::Hash[String, String]).returns(T::Hash[String, String]) }
+    def run_bundle_install_through_command(env)
+      base_bundle = base_bundle_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 custom bundle was just created
+      # to upgrade them or else we'll produce undesired source control changes. If the composed bundle was just created
       # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
       # install` for the first time to generate the Gemfile.lock with them included or else Bundler will complain that
       # they're missing. We can only update if the custom `.ruby-lsp/Gemfile.lock` already exists and includes all gems
@@ -232,16 +292,16 @@ module RubyLsp
       command << "1>&2"
 
       # Add bundle update
-      $stderr.puts("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
+      $stderr.puts("Ruby LSP> Running bundle install for the composed bundle. This may take a while...")
       $stderr.puts("Ruby LSP> Command: #{command}")
 
-      # Try to run the bundle install or update command. If that fails, it normally means that the custom lockfile is in
-      # a bad state that no longer reflects the top level one. In that case, we can remove the whole directory, try
+      # Try to run the bundle install or update command. If that fails, it normally means that the composed lockfile is
+      # in a bad state that no longer reflects the top level one. In that case, we can remove the whole directory, try
       # another time and give up if it fails again
-      if !system(env, command) && !@retry && @custom_dir.exist?
+      if !system(env, command) && !@retry && @custom_gemfile.exist?
         @retry = true
         @custom_dir.rmtree
-        $stderr.puts("Ruby LSP> Running bundle install failed. Trying to re-generate the custom bundle from scratch")
+        $stderr.puts("Ruby LSP> Running bundle install failed. Trying to re-generate the composed bundle from scratch")
         return setup!
       end
 
@@ -288,14 +348,14 @@ module RubyLsp
       if @rails_app
         return false if @dependencies.values_at("ruby-lsp", "ruby-lsp-rails", "debug").all?
 
-        # If the custom lockfile doesn't include `ruby-lsp`, `ruby-lsp-rails` or `debug`, we need to run bundle install
-        # before updating
-        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug", "ruby-lsp-rails").any?(&:nil?)
+        # If the composed lockfile doesn't include `ruby-lsp`, `ruby-lsp-rails` or `debug`, we need to run bundle
+        # install before updating
+        return false if composed_bundle_dependencies.values_at("ruby-lsp", "debug", "ruby-lsp-rails").any?(&:nil?)
       else
         return false if @dependencies.values_at("ruby-lsp", "debug").all?
 
-        # If the custom lockfile doesn't include `ruby-lsp` or `debug`, we need to run bundle install before updating
-        return false if custom_bundle_dependencies.values_at("ruby-lsp", "debug").any?(&:nil?)
+        # If the composed lockfile doesn't include `ruby-lsp` or `debug`, we need to run bundle install before updating
+        return false if composed_bundle_dependencies.values_at("ruby-lsp", "debug").any?(&:nil?)
       end
 
       # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update
@@ -312,11 +372,14 @@ module RubyLsp
 
         # 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&.start_with?(".")
+        if path && !URI(path).scheme
           "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
         else
           match
         end
+      rescue URI::InvalidURIError, URI::InvalidComponentError
+        # If the path raises an invalid error, it might be a git ssh path, which indeed isn't a URI
+        match
       end
 
       @custom_lockfile.write(content)
@@ -331,5 +394,49 @@ module RubyLsp
 
       /class .* < (::)?Rails::Application/.match?(application_contents)
     end
+
+    # Returns the base bundle command we should use for this project, which will be:
+    # - `bundle` if there's no locked Bundler version and no `bin/bundle` binstub in the $PATH
+    # - `bundle _<version>_` if there's a locked Bundler version
+    # - `bin/bundle` if there's a `bin/bundle` binstub in the $PATH
+    sig { params(env: T::Hash[String, String]).returns(String) }
+    def base_bundle_command(env)
+      path_parts = if Gem.win_platform?
+        ENV["Path"] || ENV["PATH"] || ENV["path"] || ""
+      else
+        ENV["PATH"] || ""
+      end.split(File::PATH_SEPARATOR)
+
+      bin_dir = File.expand_path("bin", @project_path)
+      bundle_binstub = File.join(@project_path, "bin", "bundle")
+
+      if File.exist?(bundle_binstub) && path_parts.any? { |path| File.expand_path(path, @project_path) == bin_dir }
+        return bundle_binstub
+      end
+
+      if @bundler_version
+        env["BUNDLER_VERSION"] = @bundler_version.to_s
+        install_bundler_if_needed
+        return "bundle _#{@bundler_version}_"
+      end
+
+      "bundle"
+    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
+
+        sig { returns(IO) }
+        def stdout
+          $stderr
+        end
+      end)
+
+      Bundler.ui.level = :info
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -7,9 +7,6 @@ module RubyLsp
 
     class NonExistingDocumentError < StandardError; end
 
-    sig { returns(T::Boolean) }
-    attr_accessor :supports_progress
-
     sig { returns(T::Hash[Symbol, RequestConfig]) }
     attr_accessor :features_configuration
 
@@ -19,7 +16,6 @@ module RubyLsp
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document[T.untyped]])
-      @supports_progress = T.let(true, T::Boolean)
       @features_configuration = T.let(
         {
           inlayHint: RequestConfig.new({

data/lib/ruby_lsp/utils.rb

@@ -79,6 +79,69 @@ module RubyLsp
           params: Interface::LogMessageParams.new(type: type, message: message),
         )
       end
+
+      sig { params(data: T::Hash[Symbol, T.untyped]).returns(Notification) }
+      def telemetry(data)
+        new(
+          method: "telemetry/event",
+          params: data,
+        )
+      end
+
+      sig do
+        params(
+          id: String,
+          title: String,
+          percentage: T.nilable(Integer),
+          message: T.nilable(String),
+        ).returns(Notification)
+      end
+      def progress_begin(id, title, percentage: nil, message: nil)
+        new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressBegin.new(
+              kind: "begin",
+              title: title,
+              percentage: percentage,
+              message: message,
+            ),
+          ),
+        )
+      end
+
+      sig do
+        params(
+          id: String,
+          percentage: T.nilable(Integer),
+          message: T.nilable(String),
+        ).returns(Notification)
+      end
+      def progress_report(id, percentage: nil, message: nil)
+        new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressReport.new(
+              kind: "report",
+              percentage: percentage,
+              message: message,
+            ),
+          ),
+        )
+      end
+
+      sig { params(id: String).returns(Notification) }
+      def progress_end(id)
+        Notification.new(
+          method: "$/progress",
+          params: Interface::ProgressParams.new(
+            token: id,
+            value: Interface::WorkDoneProgressEnd.new(kind: "end"),
+          ),
+        )
+      end
     end
 
     extend T::Sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.22.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-16 00:00:00.000000000 Z
+date: 2024-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -84,6 +84,7 @@ email:
 executables:
 - ruby-lsp
 - ruby-lsp-check
+- ruby-lsp-launcher
 extensions: []
 extra_rdoc_files: []
 files:
@@ -92,6 +93,7 @@ files:
 - VERSION
 - exe/ruby-lsp
 - exe/ruby-lsp-check
+- exe/ruby-lsp-launcher
 - lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
@@ -121,6 +123,7 @@ files:
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
+- lib/ruby_lsp/client_capabilities.rb
 - lib/ruby_lsp/document.rb
 - lib/ruby_lsp/erb_document.rb
 - lib/ruby_lsp/global_state.rb
@@ -183,6 +186,8 @@ files:
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/ruby_document.rb
 - lib/ruby_lsp/scope.rb
+- lib/ruby_lsp/scripts/compose_bundle.rb
+- lib/ruby_lsp/scripts/compose_bundle_windows.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/static_docs.rb
@@ -212,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby