ruby-lsp 0.22.0 → 0.23.0

data/lib/ruby_lsp/server.rb

@@ -71,6 +71,8 @@ module RubyLsp
         text_document_prepare_type_hierarchy(message)
       when "textDocument/rename"
         text_document_rename(message)
+      when "textDocument/prepareRename"
+        text_document_prepare_rename(message)
       when "textDocument/references"
         text_document_references(message)
       when "typeHierarchy/supertypes"
@@ -117,12 +119,24 @@ module RubyLsp
         # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
         # from disk and it raise this error. This is expected, so we don't include the `data` attribute to avoid
         # reporting these to our telemetry
-        if e.is_a?(Store::NonExistingDocumentError)
+        case e
+        when Store::NonExistingDocumentError
           send_message(Error.new(
             id: message[:id],
             code: Constant::ErrorCodes::INVALID_PARAMS,
             message: e.full_message,
           ))
+        when Document::LocationNotFoundError
+          send_message(Error.new(
+            id: message[:id],
+            code: Constant::ErrorCodes::REQUEST_FAILED,
+            message: <<~MESSAGE,
+              Request #{message[:method]} failed to find the target position.
+              The file might have been modified while the server was in the middle of searching for the target.
+              If you experience this regularly, please report any findings and extra information on
+              https://github.com/Shopify/ruby-lsp/issues/2446
+            MESSAGE
+          ))
         else
           send_message(Error.new(
             id: message[:id],
@@ -237,6 +251,7 @@ module RubyLsp
       completion_provider = Requests::Completion.provider if enabled_features["completion"]
       signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
       type_hierarchy_provider = Requests::PrepareTypeHierarchy.provider if enabled_features["typeHierarchy"]
+      rename_provider = Requests::Rename.provider unless @global_state.has_type_checker
 
       response = {
         capabilities: Interface::ServerCapabilities.new(
@@ -263,7 +278,7 @@ module RubyLsp
           workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
           type_hierarchy_provider: type_hierarchy_provider,
-          rename_provider: !@global_state.has_type_checker,
+          rename_provider: rename_provider,
           references_provider: !@global_state.has_type_checker,
           document_range_formatting_provider: true,
           experimental: {
@@ -727,6 +742,24 @@ module RubyLsp
       send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_prepare_rename(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::PrepareRename.new(document, params[:position]).perform,
+        ),
+      )
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_references(message)
       params = message[:params]
@@ -981,15 +1014,17 @@ module RubyLsp
         next unless file_path.end_with?(".rb")
 
         load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-        indexable = RubyIndexer::IndexablePath.new(load_path_entry, file_path)
+        uri.add_require_path_from_load_entry(load_path_entry) if load_path_entry
+
+        content = File.read(file_path)
 
         case change[:type]
         when Constant::FileChangeType::CREATED
-          index.index_single(indexable)
+          index.index_single(uri, content)
         when Constant::FileChangeType::CHANGED
-          index.handle_change(indexable)
+          index.handle_change(uri, content)
         when Constant::FileChangeType::DELETED
-          index.delete(indexable)
+          index.delete(uri)
         end
       end
 
@@ -1088,7 +1123,7 @@ module RubyLsp
 
     sig { override.void }
     def shutdown
-      Addon.addons.each(&:deactivate)
+      Addon.unload_addons
     end
 
     sig { void }

data/lib/ruby_lsp/setup_bundler.rb

@@ -45,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
@@ -91,10 +94,8 @@ 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 composed bundle setup since #{@custom_lockfile} already exists and is up to date",
         )
@@ -103,7 +104,7 @@ module RubyLsp
 
       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
 
@@ -151,7 +152,13 @@ module RubyLsp
       end
 
       unless @dependencies["debug"]
-        parts << 'gem "debug", require: false, group: :development, platforms: :mri'
+        # The `mri` platform excludes Windows. We want to install the debug gem only on MRI for any operating system,
+        # but that constraint doesn't yet exist in Bundler. On Windows, we are manually checking if the engine is MRI
+        parts << if Gem.win_platform?
+          'gem "debug", require: false, group: :development, install_if: -> { RUBY_ENGINE == "ruby" }'
+        else
+          'gem "debug", require: false, group: :development, platforms: :mri'
+        end
       end
 
       if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -195,15 +202,15 @@ 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
+      # Set the specific Bundler version used by the main app. This avoids issues with Bundler restarts, which clean the
+      # environment and lead to the `ruby-lsp` executable not being found
       if @bundler_version
         env["BUNDLER_VERSION"] = @bundler_version.to_s
         install_bundler_if_needed
       end
 
+      return run_bundle_install_through_command(env) unless @launcher
+
       begin
         run_bundle_install_directly(env)
         # If no error occurred, then clear previous errors
@@ -214,15 +221,36 @@ module RubyLsp
         @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)
+    sig { params(env: T::Hash[String, String], force_install: T::Boolean).returns(T::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)
 
-      unless should_bundle_update?
+      unless should_update && !force_install
         Bundler::CLI::Install.new({}).run
         correct_relative_remote_paths if @custom_lockfile.exist?
         return env
@@ -237,12 +265,13 @@ module RubyLsp
       correct_relative_remote_paths if @custom_lockfile.exist?
       @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]) }
     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 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
@@ -251,13 +280,20 @@ 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 = +"(#{base_bundle} check"
+      bundler_path = File.join(Gem.default_bindir, "bundle")
+      base_command = (File.exist?(bundler_path) ? "#{Gem.ruby} #{bundler_path}" : "bundle").dup
+
+      if env["BUNDLER_VERSION"]
+        base_command << " _#{env["BUNDLER_VERSION"]}_"
+      end
+
+      command = +"(#{base_command} 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 << " && #{base_bundle} update "
+        command << " && #{base_command} update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
@@ -267,7 +303,7 @@ module RubyLsp
         @last_updated_path.write(Time.now.iso8601)
       end
 
-      command << " || #{base_bundle} install) "
+      command << " || #{base_command} install) "
 
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
@@ -377,34 +413,6 @@ 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)

data/lib/ruby_lsp/test_helper.rb

@@ -1,11 +1,16 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 # NOTE: This module is intended to be used by addons for writing their own tests, so keep that in mind if changing.
 
 module RubyLsp
   module TestHelper
+    class TestError < StandardError; end
+
     extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
 
     sig do
       type_parameters(:T)
@@ -36,20 +41,49 @@ module RubyLsp
             },
           },
         })
+
+        server.global_state.index.index_single(uri, source)
       end
 
-      server.global_state.index.index_single(
-        RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)),
-        source,
-      )
       server.load_addons(include_project_addons: false) if load_addons
-      block.call(server, uri)
-    ensure
-      if load_addons
-        RubyLsp::Addon.addons.each(&:deactivate)
-        RubyLsp::Addon.addons.clear
+
+      begin
+        block.call(server, uri)
+      ensure
+        if load_addons
+          RubyLsp::Addon.addons.each(&:deactivate)
+          RubyLsp::Addon.addons.clear
+        end
+        server.run_shutdown
+      end
+    end
+
+    sig { params(server: RubyLsp::Server).returns(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)
+
+      if result.is_a?(RubyLsp::Error)
+        raise TestError, "Failed to execute request #{result.message}"
+      else
+        result
       end
-      T.must(server).run_shutdown
+    end
+
+    def pop_log_notification(message_queue, type)
+      log = message_queue.pop
+      return log if log.params.type == type
+
+      log = message_queue.pop until log.params.type == type
+      log
+    end
+
+    def pop_message(outgoing_queue, &block)
+      message = outgoing_queue.pop
+      return message if block.call(message)
+
+      message = outgoing_queue.pop until block.call(message)
+      message
     end
   end
 end

data/lib/ruby_lsp/type_inferrer.rb

@@ -23,6 +23,9 @@ module RubyLsp
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
         Prism::SuperNode, Prism::ForwardingSuperNode
         self_receiver_handling(node_context)
+      when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
+        Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+        infer_receiver_for_class_variables(node_context)
       end
     end
 
@@ -143,6 +146,25 @@ module RubyLsp
       nil
     end
 
+    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
+    def infer_receiver_for_class_variables(node_context)
+      nesting_parts = node_context.nesting.dup
+
+      return Type.new("Object") if nesting_parts.empty?
+
+      nesting_parts.reverse_each do |part|
+        break unless part.include?("<Class:")
+
+        nesting_parts.pop
+      end
+
+      receiver_name = nesting_parts.join("::")
+      resolved_receiver = @index.resolve(receiver_name, node_context.nesting)&.first
+      return unless resolved_receiver&.name
+
+      Type.new(resolved_receiver.name)
+    end
+
     # A known type
     class Type
       extend T::Sig

data/lib/ruby_lsp/utils.rb

@@ -173,6 +173,9 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :message
 
+    sig { returns(Integer) }
+    attr_reader :code
+
     sig { params(id: Integer, code: Integer, message: String, data: T.nilable(T::Hash[Symbol, T.untyped])).void }
     def initialize(id:, code:, message:, data: nil)
       @id = id

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Shopify
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2025-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -94,7 +93,6 @@ files:
 - 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
 - lib/ruby-lsp.rb
@@ -103,12 +101,13 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/enhancement.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
-- lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
 - lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
 - lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
 - lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb
+- lib/ruby_indexer/lib/ruby_indexer/uri.rb
 - lib/ruby_indexer/ruby_indexer.rb
+- lib/ruby_indexer/test/class_variables_test.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
@@ -121,6 +120,7 @@ files:
 - lib/ruby_indexer/test/rbs_indexer_test.rb
 - lib/ruby_indexer/test/reference_finder_test.rb
 - lib/ruby_indexer/test/test_case.rb
+- lib/ruby_indexer/test/uri_test.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
 - lib/ruby_lsp/client_capabilities.rb
@@ -157,6 +157,7 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
+- lib/ruby_lsp/requests/prepare_rename.rb
 - lib/ruby_lsp/requests/prepare_type_hierarchy.rb
 - lib/ruby_lsp/requests/range_formatting.rb
 - lib/ruby_lsp/requests/references.rb
@@ -202,7 +203,6 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   documentation_uri: https://shopify.github.io/ruby-lsp/
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -217,8 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.23
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []

data/lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb

@@ -1,29 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyIndexer
-  class IndexablePath
-    extend T::Sig
-
-    sig { returns(T.nilable(String)) }
-    attr_reader :require_path
-
-    sig { returns(String) }
-    attr_reader :full_path
-
-    # An IndexablePath is instantiated with a load_path_entry and a full_path. The load_path_entry is where the file can
-    # be found in the $LOAD_PATH, which we use to determine the require_path. The load_path_entry may be `nil` if the
-    # indexer is configured to go through files that do not belong in the $LOAD_PATH. For example,
-    # `sorbet/tapioca/require.rb` ends up being a part of the paths to be indexed because it's a Ruby file inside the
-    # project, but the `sorbet` folder is not a part of the $LOAD_PATH. That means that both its load_path_entry and
-    # require_path will be `nil`, since it cannot be required by the project
-    sig { params(load_path_entry: T.nilable(String), full_path: String).void }
-    def initialize(load_path_entry, full_path)
-      @full_path = full_path
-      @require_path = T.let(
-        load_path_entry ? full_path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb") : nil,
-        T.nilable(String),
-      )
-    end
-  end
-end