ruby-lsp 0.20.1 → 0.21.1

data/lib/ruby_lsp/requests/request.rb

@@ -26,7 +26,7 @@ module RubyLsp
         ).void
       end
       def delegate_request_if_needed!(global_state, document, char_position)
-        if global_state.supports_request_delegation &&
+        if global_state.client_capabilities.supports_request_delegation &&
             document.is_a?(ERBDocument) &&
             document.inside_host_language?(char_position)
           raise DelegateRequestError

data/lib/ruby_lsp/requests/support/rubocop_runner.rb

@@ -1,16 +1,26 @@
 # typed: strict
 # frozen_string_literal: true
 
+# If there's no top level Gemfile, don't load RuboCop from a global installation
+begin
+  Bundler.with_original_env { Bundler.default_gemfile }
+rescue Bundler::GemfileNotFound
+  return
+end
+
+# Ensure that RuboCop is available
 begin
   require "rubocop"
 rescue LoadError
   return
 end
 
+# Ensure that RuboCop is at least version 1.4.0
 begin
   gem("rubocop", ">= 1.4.0")
 rescue LoadError
-  raise StandardError, "Incompatible RuboCop version. Ruby LSP requires >= 1.4.0"
+  $stderr.puts "Incompatible RuboCop version. Ruby LSP requires >= 1.4.0"
+  return
 end
 
 if RuboCop.const_defined?(:LSP) # This condition will be removed when requiring RuboCop >= 1.61.

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+def compose(raw_initialize)
+  require_relative "../setup_bundler"
+  require "json"
+  require "uri"
+  require_relative "../../core_ext/uri"
+
+  initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
+  workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)
+  workspace_path = workspace_uri && URI(workspace_uri).to_standardized_path
+  workspace_path ||= Dir.pwd
+
+  env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
+  File.write(
+    File.join(".ruby-lsp", "bundle_env"),
+    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
+  )
+end

data/lib/ruby_lsp/scripts/compose_bundle_windows.rb

@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "compose_bundle"
+
+# When this is invoked on Windows, we pass the raw initialize as an argument to this script. On other platforms, we
+# invoke the compose method from inside a forked process
+compose(ARGV.first)

data/lib/ruby_lsp/server.rb

@@ -81,6 +81,8 @@ module RubyLsp
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
         workspace_symbol(message)
+      when "window/showMessageRequest"
+        window_show_message_request(message)
       when "rubyLsp/textDocument/showSyntaxTree"
         text_document_show_syntax_tree(message)
       when "rubyLsp/workspace/dependencies"
@@ -140,6 +142,11 @@ module RubyLsp
 
     sig { params(include_project_addons: T::Boolean).void }
     def load_addons(include_project_addons: true)
+      # If invoking Bundler.setup failed, then the load path will not be configured properly and trying to load add-ons
+      # with Gem.find_files will find every single version installed of an add-on, leading to requiring several
+      # different versions of the same files. We cannot load add-ons if Bundler.setup failed
+      return if @setup_error
+
       errors = Addon.load_addons(@global_state, @outgoing_queue, include_project_addons: include_project_addons)
 
       if errors.any?
@@ -254,12 +261,13 @@ module RubyLsp
           version: VERSION,
         },
         formatter: @global_state.formatter,
+        degraded_mode: !!(@install_error || @setup_error),
       }
 
       send_message(Result.new(id: message[:id], response: response))
 
       # Not every client supports dynamic registration or file watching
-      if global_state.supports_watching_files
+      if @global_state.client_capabilities.supports_watching_files
         send_message(
           Request.new(
             id: @current_request_id,
@@ -290,6 +298,24 @@ module RubyLsp
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
       global_state_notifications.each { |notification| send_message(notification) }
+
+      if @setup_error
+        send_message(Notification.telemetry(
+          type: "error",
+          errorMessage: @setup_error.message,
+          errorClass: @setup_error.class,
+          stack: @setup_error.backtrace&.join("\n"),
+        ))
+      end
+
+      if @install_error
+        send_message(Notification.telemetry(
+          type: "error",
+          errorMessage: @install_error.message,
+          errorClass: @install_error.class,
+          stack: @install_error.backtrace&.join("\n"),
+        ))
+      end
     end
 
     sig { void }
@@ -297,20 +323,22 @@ module RubyLsp
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      if defined?(Requests::Support::RuboCopFormatter)
-        begin
-          @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
-        rescue RuboCop::Error => e
-          # The user may have provided unknown config switches in .rubocop or
-          # is trying to load a non-existant config file.
-          send_message(Notification.window_show_message(
-            "RuboCop configuration error: #{e.message}. Formatting will not be available.",
-            type: Constant::MessageType::ERROR,
-          ))
+      unless @setup_error
+        if defined?(Requests::Support::RuboCopFormatter)
+          begin
+            @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+          rescue RuboCop::Error => e
+            # The user may have provided unknown config switches in .rubocop or
+            # is trying to load a non-existent config file.
+            send_message(Notification.window_show_message(
+              "RuboCop configuration error: #{e.message}. Formatting will not be available.",
+              type: Constant::MessageType::ERROR,
+            ))
+          end
+        end
+        if defined?(Requests::Support::SyntaxTreeFormatter)
+          @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
         end
-      end
-      if defined?(Requests::Support::SyntaxTreeFormatter)
-        @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
       end
 
       perform_initial_indexing
@@ -1017,7 +1045,7 @@ module RubyLsp
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
-      response = begin
+      response = if @global_state.top_level_bundle
         Bundler.with_original_env do
           definition = Bundler.definition
           dep_keys = definition.locked_deps.keys.to_set
@@ -1031,7 +1059,7 @@ module RubyLsp
             }
           end
         end
-      rescue Bundler::GemfileNotFound
+      else
         []
       end
 
@@ -1138,6 +1166,7 @@ module RubyLsp
 
     sig { void }
     def check_formatter_is_available
+      return if @setup_error
       # Warn of an unavailable `formatter` setting, e.g. `rubocop` on a project which doesn't have RuboCop.
       # Syntax Tree will always be available via Ruby LSP so we don't need to check for it.
       return unless @global_state.formatter == "rubocop"
@@ -1194,5 +1223,14 @@ module RubyLsp
       # The index expects snake case configurations, but VS Code standardizes on camel case settings
       configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
     end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def window_show_message_request(message)
+      addon_name = message[:addon_name]
+      addon = Addon.addons.find { |addon| addon.name == addon_name }
+      return unless addon
+
+      addon.handle_window_show_message_response(message[:title])
+    end
   end
 end

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,6 +53,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])
@@ -59,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"] &&
@@ -69,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?
@@ -111,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 }
@@ -134,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"')
@@ -191,16 +195,54 @@ 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
+
+      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
@@ -238,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")
@@ -312,11 +354,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 +376,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.1
+  version: 0.21.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-16 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