ruby-lsp 0.20.0 → 0.21.0

data/lib/ruby_lsp/setup_bundler.rb

@@ -3,10 +3,14 @@
 
 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
 # the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
@@ -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(
@@ -47,8 +53,11 @@ 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 = T.let(load_dependencies, T::Hash[String, T.untyped])
+      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)
     end
@@ -57,7 +66,12 @@ module RubyLsp
     # 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?
+
+      # 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 custom bundle if LSP dependencies are already in the Gemfile
       if @dependencies["ruby-lsp"] &&
@@ -67,19 +81,9 @@ module RubyLsp
           "Ruby LSP> Skipping custom 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?
@@ -109,17 +113,19 @@ module RubyLsp
     def custom_bundle_dependencies
       @custom_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,7 +138,7 @@ 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 @gemfile&.exist? && @lockfile&.exist?
         parts << "eval_gemfile(File.expand_path(\"../#{@gemfile_name}\", __dir__))"
       else
         parts.unshift('source "https://rubygems.org"')
@@ -156,14 +162,15 @@ module RubyLsp
       @custom_gemfile.write(content) unless @custom_gemfile.exist? && @custom_gemfile.read == content
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns([T::Hash[String, T.untyped], T.nilable(Gem::Version)]) }
     def load_dependencies
-      return {} unless @lockfile&.exist?
+      return [{}, nil] 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(@lockfile.read).dependencies
+      lockfile_parser = Bundler::LockfileParser.new(@lockfile.read)
+      dependencies = lockfile_parser.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. Notice that bundler allows more than one
@@ -172,7 +179,7 @@ module RubyLsp
         dependencies.merge!(Bundler.load_gemspec(path).dependencies.to_h { |dep| [dep.name, dep] })
       end
 
-      dependencies
+      [dependencies, lockfile_parser.bundler_version]
     end
 
     sig { params(bundle_gemfile: T.nilable(Pathname)).returns(T::Hash[String, String]) }
@@ -188,6 +195,54 @@ module RubyLsp
         env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
       end
 
+      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
+      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
+
+      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
       # and any of `ruby-lsp`, `ruby-lsp-rails` or `debug` weren't a part of the Gemfile, then we need to run `bundle
@@ -196,13 +251,13 @@ module RubyLsp
 
       # When not updating, we run `(bundle check || bundle install)`
       # When updating, we run `((bundle check && bundle update ruby-lsp debug) || bundle install)`
-      command = +"(bundle check"
+      command = +"(#{base_bundle} check"
 
       if should_bundle_update?
         # If any of `ruby-lsp`, `ruby-lsp-rails` or `debug` are not in the Gemfile, try to update them to the latest
         # version
         command.prepend("(")
-        command << " && bundle update "
+        command << " && #{base_bundle} update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -212,7 +267,7 @@ module RubyLsp
         @last_updated_path.write(Time.now.iso8601)
       end
 
-      command << " || bundle install) "
+      command << " || #{base_bundle} install) "
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
@@ -225,7 +280,7 @@ module RubyLsp
       # 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
       # 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")
@@ -259,6 +314,15 @@ module RubyLsp
       end
     end
 
+    sig { 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)
+      return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
+
+      Gem.install("bundler", @bundler_version.to_s)
+    end
+
     sig { returns(T::Boolean) }
     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
@@ -290,7 +354,7 @@ 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
@@ -309,5 +373,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/utils.rb

@@ -79,6 +79,14 @@ 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
     end
 
     extend T::Sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-10-31 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.22
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby