ruby-lsp 0.10.0 → 0.11.0

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

@@ -5,12 +5,13 @@ module RubyLsp
   module Requests
     module Support
       module Common
-        # WARNING: Methods in this class may be used by Ruby LSP extensions such as https://github.com/Shopify/ruby-lsp-rails,
-        # or extensions by created by developers outside of Shopify, so be cautious of changing anything.
+        # WARNING: Methods in this class may be used by Ruby LSP addons such as
+        # https://github.com/Shopify/ruby-lsp-rails, or addons by created by developers outside of Shopify, so be
+        # cautious of changing anything.
         extend T::Sig
 
-        sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
-        def range_from_syntax_tree_node(node)
+        sig { params(node: YARP::Node).returns(Interface::Range) }
+        def range_from_node(node)
           loc = node.location
 
           Interface::Range.new(
@@ -22,28 +23,18 @@ module RubyLsp
           )
         end
 
-        sig do
-          params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
-        end
-        def full_constant_name(node)
-          name = node.constant.value.dup
-          constant = T.let(node, SyntaxTree::Node)
-
-          while constant.is_a?(SyntaxTree::ConstPathRef)
-            constant = constant.parent
-
-            case constant
-            when SyntaxTree::ConstPathRef
-              name.prepend("#{constant.constant.value}::")
-            when SyntaxTree::VarRef
-              name.prepend("#{constant.value.value}::")
-            end
-          end
-
-          name
+        sig { params(location: YARP::Location).returns(Interface::Range) }
+        def range_from_location(location)
+          Interface::Range.new(
+            start: Interface::Position.new(
+              line: location.start_line - 1,
+              character: location.start_column,
+            ),
+            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+          )
         end
 
-        sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+        sig { params(node: T.nilable(YARP::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
         def visible?(node, range)
           return true if range.nil?
           return false if node.nil?
@@ -54,7 +45,7 @@ module RubyLsp
 
         sig do
           params(
-            node: SyntaxTree::Node,
+            node: YARP::Node,
             title: String,
             command_name: String,
             arguments: T.nilable(T::Array[T.untyped]),
@@ -62,7 +53,7 @@ module RubyLsp
           ).returns(Interface::CodeLens)
         end
         def create_code_lens(node, title:, command_name:, arguments:, data:)
-          range = range_from_syntax_tree_node(node)
+          range = range_from_node(node)
 
           Interface::CodeLens.new(
             range: range,

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

@@ -1,55 +1,80 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "singleton"
+
 module RubyLsp
-  module DependencyDetector
-    class << self
-      extend T::Sig
-
-      sig { returns(String) }
-      def detected_formatter
-        # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-        if direct_dependency?(/^rubocop/)
-          "rubocop"
-        elsif direct_dependency?(/^syntax_tree$/)
-          "syntax_tree"
-        else
-          "none"
-        end
-      end
+  class DependencyDetector
+    include Singleton
+    extend T::Sig
 
-      sig { returns(String) }
-      def detected_test_library
-        # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
-        # by ruby-lsp-rails.
-        if direct_dependency?(/^rails$/)
-          "rails"
-        # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
-        elsif direct_dependency?(/^minitest$/)
-          "minitest"
-        elsif direct_dependency?(/^test-unit/)
-          "test-unit"
-        elsif direct_dependency?(/^rspec/)
-          "rspec"
-        else
-          "unknown"
-        end
-      end
+    sig { returns(String) }
+    attr_reader :detected_formatter
+
+    sig { returns(String) }
+    attr_reader :detected_test_library
+
+    sig { returns(T::Boolean) }
+    attr_reader :typechecker
+
+    sig { void }
+    def initialize
+      @detected_formatter = T.let(detect_formatter, String)
+      @detected_test_library = T.let(detect_test_library, String)
+      @typechecker = T.let(detect_typechecker, T::Boolean)
+    end
 
-      sig { returns(T::Boolean) }
-      def typechecker?
-        direct_dependency?(/^sorbet/) || direct_dependency?(/^sorbet-static-and-runtime/)
+    sig { returns(String) }
+    def detect_formatter
+      # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
+      if direct_dependency?(/^rubocop/)
+        "rubocop"
+      elsif direct_dependency?(/^syntax_tree$/)
+        "syntax_tree"
+      else
+        "none"
       end
+    end
 
-      sig { params(gem_pattern: Regexp).returns(T::Boolean) }
-      def direct_dependency?(gem_pattern)
-        Bundler.with_original_env { Bundler.default_gemfile } &&
-          Bundler.locked_gems.dependencies.keys.grep(gem_pattern).any?
-      rescue Bundler::GemfileNotFound
-        false
+    sig { returns(String) }
+    def detect_test_library
+      # A Rails app may have a dependency on minitest, but we would instead want to use the Rails test runner provided
+      # by ruby-lsp-rails.
+      if direct_dependency?(/^rails$/)
+        "rails"
+      # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
+      elsif direct_dependency?(/^minitest$/)
+        "minitest"
+      elsif direct_dependency?(/^test-unit/)
+        "test-unit"
+      elsif direct_dependency?(/^rspec/)
+        "rspec"
+      else
+        "unknown"
       end
     end
 
-    HAS_TYPECHECKER = T.let(typechecker?, T::Boolean)
+    sig { params(gem_pattern: Regexp).returns(T::Boolean) }
+    def direct_dependency?(gem_pattern)
+      dependency_keys.grep(gem_pattern).any?
+    end
+
+    sig { returns(T::Boolean) }
+    def detect_typechecker
+      direct_dependency?(/^sorbet/) || direct_dependency?(/^sorbet-static-and-runtime/)
+    end
+
+    sig { returns(T::Array[String]) }
+    def dependency_keys
+      @dependency_keys ||= T.let(
+        begin
+          Bundler.with_original_env { Bundler.default_gemfile }
+          Bundler.locked_gems.dependencies.keys
+        rescue Bundler::GemfileNotFound
+          []
+        end,
+        T.nilable(T::Array[String]),
+      )
+    end
   end
 end

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

@@ -16,81 +16,100 @@ module RubyLsp
           sig { returns(Integer) }
           attr_reader :type
 
-          sig { returns(SyntaxTree::Node) }
-          attr_reader :node
+          sig { returns(YARP::Location) }
+          attr_reader :location
 
-          sig { params(type: Integer, node: SyntaxTree::Node).void }
-          def initialize(type:, node:)
+          sig { params(type: Integer, location: YARP::Location).void }
+          def initialize(type:, location:)
             @type = type
-            @node = node
+            @location = location
           end
         end
 
-        sig { params(node: SyntaxTree::Node).void }
+        sig { params(node: YARP::Node).void }
         def initialize(node)
           @node = node
           @value = T.let(value(node), T.nilable(String))
         end
 
-        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        sig { params(other: YARP::Node).returns(T.nilable(HighlightMatch)) }
         def highlight_type(other)
-          matched_highlight(other) if other.is_a?(SyntaxTree::Params) || (@value && @value == value(other))
+          matched_highlight(other) if @value && @value == value(other)
         end
 
         private
 
         # Match the target type (where the cursor is positioned) with the `other` type (the node we're currently
         # visiting)
-        sig { params(other: SyntaxTree::Node).returns(T.nilable(HighlightMatch)) }
+        sig { params(other: YARP::Node).returns(T.nilable(HighlightMatch)) }
         def matched_highlight(other)
           case @node
           # Method definitions and invocations
-          when SyntaxTree::VCall, SyntaxTree::CallNode, SyntaxTree::Command,
-               SyntaxTree::CommandCall, SyntaxTree::DefNode
+          when YARP::CallNode, YARP::DefNode
             case other
-            when SyntaxTree::VCall, SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
-              HighlightMatch.new(type: READ, node: other)
-            when SyntaxTree::DefNode
-              HighlightMatch.new(type: WRITE, node: other.name)
+            when YARP::CallNode
+              HighlightMatch.new(type: READ, location: other.location)
+            when YARP::DefNode
+              HighlightMatch.new(type: WRITE, location: other.name_loc)
             end
           # Variables, parameters and constants
-          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::VarField,
-               SyntaxTree::VarRef, SyntaxTree::Ident
+          else
             case other
-            when SyntaxTree::VarField
-              HighlightMatch.new(type: WRITE, node: other)
-            when SyntaxTree::VarRef
-              HighlightMatch.new(type: READ, node: other)
-            when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
-              HighlightMatch.new(type: WRITE, node: other.constant)
-            when SyntaxTree::ConstPathRef
-              HighlightMatch.new(type: READ, node: other.constant)
-            when SyntaxTree::Params
-              params = other.child_nodes.compact
-              match = params.find { |param| value(param) == @value }
-              HighlightMatch.new(type: WRITE, node: match) if match
+            when YARP::GlobalVariableTargetNode, YARP::InstanceVariableTargetNode, YARP::ConstantPathTargetNode,
+              YARP::ConstantTargetNode, YARP::ClassVariableTargetNode, YARP::LocalVariableTargetNode,
+              YARP::BlockParameterNode, YARP::RequiredParameterNode
+
+              HighlightMatch.new(type: WRITE, location: other.location)
+            when YARP::LocalVariableWriteNode, YARP::KeywordParameterNode, YARP::RestParameterNode,
+              YARP::OptionalParameterNode, YARP::KeywordRestParameterNode, YARP::LocalVariableAndWriteNode,
+              YARP::LocalVariableOperatorWriteNode, YARP::LocalVariableOrWriteNode, YARP::ClassVariableWriteNode,
+              YARP::ClassVariableOrWriteNode, YARP::ClassVariableOperatorWriteNode, YARP::ClassVariableAndWriteNode,
+              YARP::ConstantWriteNode, YARP::ConstantOrWriteNode, YARP::ConstantOperatorWriteNode,
+              YARP::InstanceVariableWriteNode, YARP::ConstantAndWriteNode, YARP::InstanceVariableOrWriteNode,
+              YARP::InstanceVariableAndWriteNode, YARP::InstanceVariableOperatorWriteNode,
+              YARP::GlobalVariableWriteNode, YARP::GlobalVariableOrWriteNode, YARP::GlobalVariableAndWriteNode,
+              YARP::GlobalVariableOperatorWriteNode
+
+              HighlightMatch.new(type: WRITE, location: T.must(other.name_loc)) if other.name
+            when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode, YARP::ConstantPathAndWriteNode,
+              YARP::ConstantPathOperatorWriteNode
+
+              HighlightMatch.new(type: WRITE, location: other.target.location)
+            when YARP::LocalVariableReadNode, YARP::ConstantPathNode, YARP::ConstantReadNode,
+              YARP::InstanceVariableReadNode, YARP::ClassVariableReadNode, YARP::GlobalVariableReadNode
+
+              HighlightMatch.new(type: READ, location: other.location)
+            when YARP::ClassNode, YARP::ModuleNode
+              HighlightMatch.new(type: WRITE, location: other.constant_path.location)
             end
           end
         end
 
-        sig { params(node: SyntaxTree::Node).returns(T.nilable(String)) }
+        sig { params(node: YARP::Node).returns(T.nilable(String)) }
         def value(node)
           case node
-          when SyntaxTree::ConstPathRef, SyntaxTree::ConstPathField, SyntaxTree::TopConstField
-            node.constant.value
-          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident
-            node.value
-          when SyntaxTree::Field, SyntaxTree::DefNode, SyntaxTree::RestParam,
-               SyntaxTree::KwRestParam, SyntaxTree::BlockArg
-            node.name&.value
-          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
-            value = node.value
-            value.value unless value.nil? || value.is_a?(Symbol)
-          when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
-            message = node.message
-            message.value unless message.is_a?(Symbol)
-          when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
-            node.constant.constant.value
+          when YARP::ConstantReadNode, YARP::ConstantPathNode, YARP::BlockArgumentNode, YARP::ConstantTargetNode,
+            YARP::ConstantPathWriteNode, YARP::ConstantPathTargetNode, YARP::ConstantPathOrWriteNode,
+            YARP::ConstantPathOperatorWriteNode, YARP::ConstantPathAndWriteNode
+            node.slice
+          when YARP::GlobalVariableReadNode, YARP::GlobalVariableAndWriteNode, YARP::GlobalVariableOperatorWriteNode,
+            YARP::GlobalVariableOrWriteNode, YARP::GlobalVariableTargetNode, YARP::GlobalVariableWriteNode,
+            YARP::InstanceVariableAndWriteNode, YARP::InstanceVariableOperatorWriteNode,
+            YARP::InstanceVariableOrWriteNode, YARP::InstanceVariableReadNode, YARP::InstanceVariableTargetNode,
+            YARP::InstanceVariableWriteNode, YARP::ConstantAndWriteNode, YARP::ConstantOperatorWriteNode,
+            YARP::ConstantOrWriteNode, YARP::ConstantWriteNode, YARP::ClassVariableAndWriteNode,
+            YARP::ClassVariableOperatorWriteNode, YARP::ClassVariableOrWriteNode, YARP::ClassVariableReadNode,
+            YARP::ClassVariableTargetNode, YARP::ClassVariableWriteNode, YARP::LocalVariableAndWriteNode,
+            YARP::LocalVariableOperatorWriteNode, YARP::LocalVariableOrWriteNode, YARP::LocalVariableReadNode,
+            YARP::LocalVariableTargetNode, YARP::LocalVariableWriteNode, YARP::DefNode, YARP::BlockParameterNode,
+            YARP::KeywordParameterNode, YARP::KeywordRestParameterNode, YARP::OptionalParameterNode,
+            YARP::RequiredParameterNode, YARP::RestParameterNode
+
+            node.name.to_s
+          when YARP::CallNode
+            node.message
+          when YARP::ClassNode, YARP::ModuleNode
+            node.constant_path.slice
           end
         end
       end

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

@@ -20,14 +20,19 @@ module RubyLsp
         extend T::Sig
 
         MESSAGE = <<~EOS
-          An internal error occurred for the %s cop.
+          An internal error occurred %s.
           Updating to a newer version of RuboCop may solve this.
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: RuboCop::ErrorWithAnalyzedFileLocation).void }
+        sig { params(rubocop_error: T.any(RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
         def initialize(rubocop_error)
-          message = format(MESSAGE, rubocop_error.cop.name)
+          message = case rubocop_error
+          when RuboCop::ErrorWithAnalyzedFileLocation
+            format(MESSAGE, "for the #{rubocop_error.cop.name} cop")
+          when StandardError
+            format(MESSAGE, rubocop_error.message)
+          end
           super(message)
         end
       end
@@ -87,7 +92,7 @@ module RubyLsp
           raise Formatting::Error, error.message
         rescue RuboCop::ValidationError => error
           raise ConfigurationError, error.message
-        rescue RuboCop::ErrorWithAnalyzedFileLocation => error
+        rescue StandardError => error
           raise InternalRuboCopError, error
         end
 

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

@@ -9,10 +9,11 @@ module RubyLsp
 
         sig { params(position: Document::PositionShape).returns(T::Boolean) }
         def cover?(position)
-          line_range = (range.start.line..range.end.line)
-          character_range = (range.start.character..range.end.character)
-
-          line_range.cover?(position[:line]) && character_range.cover?(position[:character])
+          start_covered = range.start.line < position[:line] ||
+            (range.start.line == position[:line] && range.start.character <= position[:character])
+          end_covered = range.end.line > position[:line] ||
+            (range.end.line == position[:line] && range.end.character >= position[:character])
+          start_covered && end_covered
         end
       end
     end

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

@@ -42,66 +42,11 @@ module RubyLsp
 
           sig do
             params(
-              node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall),
+              node: YARP::CallNode,
             ).returns(T::Boolean)
           end
           def annotation?(node)
-            annotation = annotation(node)
-
-            return false if annotation.nil?
-
-            return false unless annotation.supports_receiver?(receiver_name(node))
-
-            annotation.supports_arity?(node.arity)
-          end
-
-          private
-
-          sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(Annotation)) }
-          def annotation(node)
-            case node
-            when SyntaxTree::VCall
-              ANNOTATIONS[node.value.value]
-            when SyntaxTree::CallNode
-              message = node.message
-              ANNOTATIONS[message.value] unless message.is_a?(Symbol)
-            else
-              T.absurd(node)
-            end
-          end
-
-          sig do
-            params(receiver: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(String))
-          end
-          def receiver_name(receiver)
-            case receiver
-            when SyntaxTree::CallNode
-              node_name(receiver.receiver)
-            when SyntaxTree::VCall
-              nil
-            else
-              T.absurd(receiver)
-            end
-          end
-
-          sig do
-            params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String))
-          end
-          def node_name(node)
-            case node
-            when SyntaxTree::VarRef
-              node.value.value
-            when SyntaxTree::CallNode
-              node_name(node.receiver)
-            when SyntaxTree::VCall
-              node_name(node.value)
-            when SyntaxTree::Ident, SyntaxTree::Backtick, SyntaxTree::Const, SyntaxTree::Op
-              node.value
-            when NilClass, SyntaxTree::Node
-              nil
-            else
-              T.absurd(node)
-            end
+            !!ANNOTATIONS[node.name]&.match?(node)
           end
         end
       end

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

@@ -1,7 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "syntax_tree/cli"
+begin
+  require "syntax_tree"
+  require "syntax_tree/cli"
+rescue LoadError
+  return
+end
+
 require "singleton"
 
 module RubyLsp

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -39,12 +39,15 @@ module RubyLsp
           # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
           # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          if DependencyDetector::HAS_TYPECHECKER && bundle_path && !file_path.start_with?(bundle_path) &&
+          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
               !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
 
             next
           end
 
+          # We should never show private symbols when searching the entire workspace
+          next if entry.visibility == :private
+
           kind = kind_for_entry(entry)
           loc = entry.location
 

data/lib/ruby_lsp/server.rb

@@ -86,7 +86,7 @@ module RubyLsp
           @message_dispatcher.join
           @store.clear
 
-          Extension.extensions.each(&:deactivate)
+          Addon.addons.each(&:deactivate)
           finalize_request(Result.new(response: nil), request)
         when "exit"
           # We return zero if shutdown has already been received or one otherwise as per the recommendation in the spec
@@ -153,55 +153,17 @@ module RubyLsp
             error: {
               code: Constant::ErrorCodes::INTERNAL_ERROR,
               message: error.inspect,
-              data: request.to_json,
+              data: {
+                errorClass: error.class.name,
+                errorMessage: error.message,
+                backtrace: error.backtrace&.map { |bt| bt.sub(/^#{Dir.home}/, "~") }&.join("\n"),
+              },
             },
           )
         elsif response != VOID
           @writer.write(id: request[:id], result: response)
         end
-
-        request_time = result.request_time
-        if request_time
-          @writer.write(method: "telemetry/event", params: telemetry_params(request, request_time, error))
-        end
-      end
-    end
-
-    sig do
-      params(
-        request: T::Hash[Symbol, T.untyped],
-        request_time: Float,
-        error: T.nilable(Exception),
-      ).returns(T::Hash[Symbol, T.any(String, Float)])
-    end
-    def telemetry_params(request, request_time, error)
-      uri = request.dig(:params, :textDocument, :uri)
-      params = {
-        request: request[:method],
-        lspVersion: RubyLsp::VERSION,
-        requestTime: request_time,
-      }
-
-      if error
-        params[:errorClass] = error.class.name
-        params[:errorMessage] = error.message
-
-        log_params = request[:params]
-        params[:params] = log_params.reject { |k, _| k == :textDocument }.to_json if log_params
-
-        backtrace = error.backtrace
-        params[:backtrace] = backtrace.map { |bt| bt.sub(/^#{Dir.home}/, "~") }.join("\n") if backtrace
       end
-
-      if uri
-        home = URI::Generic.from_path(path: Dir.home)
-
-        parsed_uri = URI(uri)
-        path = parsed_uri.path
-        params[:uri] = path ? path.sub(T.must(home.path), "~") : parsed_uri.opaque
-      end
-
-      params
     end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -175,20 +175,24 @@ module RubyLsp
       # 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 both gems
-      command = +""
 
-      if should_bundle_install?
-        # Install gems using the custom bundle
-        command << "(bundle check || bundle install) "
-      else
+      # 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"
+
+      if should_bundle_update?
         # If ruby-lsp or debug are not in the Gemfile, try to update them to the latest version
-        command << "bundle update "
+        command.prepend("(")
+        command << " && bundle update "
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
-        command << "debug " unless @dependencies["debug"]
+        command << "debug" unless @dependencies["debug"]
+        command << ")"
 
         @last_updated_path.write(Time.now.iso8601)
       end
 
+      command << " || bundle install) "
+
       # Redirect stdout to stderr to prevent going into an infinite loop. The extension might confuse stdout output with
       # responses
       command << "1>&2"
@@ -200,10 +204,17 @@ module RubyLsp
     end
 
     sig { returns(T::Boolean) }
-    def should_bundle_install?
-      (!@dependencies["ruby-lsp"].nil? && !@dependencies["debug"].nil?) ||
-        custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil? ||
-        (@last_updated_path.exist? && Time.parse(@last_updated_path.read) > (Time.now - FOUR_HOURS))
+    def should_bundle_update?
+      # If both `ruby-lsp` and `debug` are in the Gemfile, then we shouldn't try to upgrade them or else it will produce
+      # version control changes
+      return false if @dependencies["ruby-lsp"] && @dependencies["debug"]
+
+      # If the custom lockfile doesn't include either the `ruby-lsp` or `debug`, we need to run bundle install before
+      # updating
+      return false if custom_bundle_dependencies["ruby-lsp"].nil? || custom_bundle_dependencies["debug"].nil?
+
+      # If the last updated file doesn't exist or was updated more than 4 hours ago, we should update
+      !@last_updated_path.exist? || Time.parse(@last_updated_path.read) < (Time.now - FOUR_HOURS)
     end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -41,20 +41,10 @@ module RubyLsp
     sig { returns(T.nilable(Exception)) }
     attr_reader :error
 
-    sig { returns(T.nilable(Float)) }
-    attr_reader :request_time
-
-    sig do
-      params(
-        response: T.untyped,
-        error: T.nilable(Exception),
-        request_time: T.nilable(Float),
-      ).void
-    end
-    def initialize(response:, error: nil, request_time: nil)
+    sig { params(response: T.untyped, error: T.nilable(Exception)).void }
+    def initialize(response:, error: nil)
       @response = response
       @error = error
-      @request_time = request_time
     end
   end