ruby-lsp 0.16.3 → 0.16.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 906f8ef7ff4c3c0da126b61e41772b36989c93e391575099121c7a31184de81c
-  data.tar.gz: 67eb8cd92613348b9b2bf7163b458ed0ba7772e4c0304c01b80e3b0c4e8b34c7
+  metadata.gz: bcd4426f17d6d429be733a9adcdf799e23c29689ad5fb69f9b9f7b3cd334bf9b
+  data.tar.gz: 071d5c37e1acf83c07a5b48e85a3bc4a18fb63a20b54ff191158799cf4320803
 SHA512:
-  metadata.gz: e6b28979f399686bf62943bb49036ed26411a11439120f8ddf52f7c86310ecc8964d32de8fffe98c12686021f8d2b019c49347de4ced546a1a2e4e1b47726bfd
-  data.tar.gz: 3339ddda6a9450cf4449a0336a38ec4bdd95b4d81e9b2aa834bfd87db11f3bb2d0caf02e5ad4d0366f040d4718046e36744750e46ef9638b78a4235f0dfad1b7
+  metadata.gz: 9edc44ec74f5f5d9b5f15fb7d22501126eb8f6bec3d9a69b3061946b369ecb0e453e45e9a0dc9df1482117dc738f7bd66005e2dcd0cd46e3aaad6f6658283766
+  data.tar.gz: c4f9ddb4da9373544b2456632a0fb76bdbca5e5ddf5e874b0e6ab4f6aae13ad8b17ef9482873b37ae33bc7ec797faebde76bf5a6e9d86e6a4ddf798b4eb9f0df

data/VERSION

@@ -1 +1 @@
-0.16.3
+0.16.5

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -11,7 +11,7 @@ module RubyIndexer
     sig { returns(String) }
     attr_reader :file_path
 
-    sig { returns(Prism::Location) }
+    sig { returns(RubyIndexer::Location) }
     attr_reader :location
 
     sig { returns(T::Array[String]) }
@@ -20,13 +20,33 @@ module RubyIndexer
     sig { returns(Symbol) }
     attr_accessor :visibility
 
-    sig { params(name: String, file_path: String, location: Prism::Location, comments: T::Array[String]).void }
+    sig do
+      params(
+        name: String,
+        file_path: String,
+        location: T.any(Prism::Location, RubyIndexer::Location),
+        comments: T::Array[String],
+      ).void
+    end
     def initialize(name, file_path, location, comments)
       @name = name
       @file_path = file_path
-      @location = location
       @comments = comments
       @visibility = T.let(:public, Symbol)
+
+      @location = T.let(
+        if location.is_a?(Prism::Location)
+          Location.new(
+            location.start_line,
+            location.end_line,
+            location.start_column,
+            location.end_column,
+          )
+        else
+          location
+        end,
+        RubyIndexer::Location,
+      )
     end
 
     sig { returns(String) }
@@ -50,7 +70,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
         ).void
       end
@@ -81,7 +101,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parent_class: T.nilable(String),
         ).void
@@ -181,7 +201,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           owner: T.nilable(Entry::Namespace),
         ).void
@@ -219,7 +239,7 @@ module RubyIndexer
         params(
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
           owner: T.nilable(Entry::Namespace),
@@ -349,7 +369,7 @@ module RubyIndexer
           nesting: T::Array[String],
           name: String,
           file_path: String,
-          location: Prism::Location,
+          location: T.any(Prism::Location, RubyIndexer::Location),
           comments: T::Array[String],
         ).void
       end

data/lib/ruby_indexer/lib/ruby_indexer/location.rb

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Location
+    extend T::Sig
+
+    sig { returns(Integer) }
+    attr_reader :start_line, :end_line, :start_column, :end_column
+
+    sig do
+      params(
+        start_line: Integer,
+        end_line: Integer,
+        start_column: Integer,
+        end_column: Integer,
+      ).void
+    end
+    def initialize(start_line, end_line, start_column, end_column)
+      @start_line = start_line
+      @end_line = end_line
+      @start_column = start_column
+      @end_column = end_column
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -10,6 +10,7 @@ require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"
 require "ruby_indexer/lib/ruby_indexer/prefix_tree"
+require "ruby_indexer/lib/ruby_indexer/location"
 
 module RubyIndexer
   @configuration = T.let(Configuration.new, Configuration)

data/lib/ruby_lsp/base_server.rb

@@ -59,9 +59,11 @@ module RubyLsp
           end
         end
 
-        # We need to process shutdown and exit from the main thread in order to close queues and wait for other threads
-        # to finish. Everything else is pushed into the incoming queue
+        # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
+        # else is pushed into the incoming queue
         case method
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+          process_message(message)
         when "shutdown"
           $stderr.puts("Shutting down Ruby LSP...")
 

data/lib/ruby_lsp/global_state.rb

@@ -20,16 +20,21 @@ module RubyLsp
     sig { returns(Encoding) }
     attr_reader :encoding
 
+    sig { returns(T::Boolean) }
+    attr_reader :supports_watching_files
+
     sig { void }
     def initialize
       @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
       @encoding = T.let(Encoding::UTF_8, Encoding)
 
       @formatter = T.let("auto", String)
-      @test_library = T.let(detect_test_library, String)
-      @typechecker = T.let(detect_typechecker, T::Boolean)
+      @linters = T.let([], T::Array[String])
+      @test_library = T.let("minitest", String)
+      @typechecker = T.let(true, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
       @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
+      @supports_watching_files = T.let(false, T::Boolean)
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -42,14 +47,25 @@ module RubyLsp
       @supported_formatters[@formatter]
     end
 
+    sig { returns(T::Array[Requests::Support::Formatter]) }
+    def active_linters
+      @linters.filter_map { |name| @supported_formatters[name] }
+    end
+
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
     def apply_options(options)
+      dependencies = gather_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
       @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter if @formatter == "auto"
+      @formatter = detect_formatter(dependencies) if @formatter == "auto"
+
+      specified_linters = options.dig(:initializationOptions, :linters)
+      @linters = specified_linters || detect_linters(dependencies)
+      @test_library = detect_test_library(dependencies)
+      @typechecker = detect_typechecker(dependencies)
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -61,6 +77,11 @@ module RubyLsp
       else
         Encoding::UTF_32
       end
+
+      file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
+      if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+        @supports_watching_files = true
+      end
     end
 
     sig { returns(String) }
@@ -80,28 +101,32 @@ module RubyLsp
       end
     end
 
-    sig { params(gem_pattern: Regexp).returns(T::Boolean) }
-    def direct_dependency?(gem_pattern)
-      dependencies.any?(gem_pattern)
-    end
-
     private
 
-    sig { returns(String) }
-    def detect_formatter
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_formatter(dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      if direct_dependency?(/^rubocop/)
+      if dependencies.any?(/^rubocop/)
         "rubocop"
-      elsif direct_dependency?(/^syntax_tree$/)
+      elsif dependencies.any?(/^syntax_tree$/)
         "syntax_tree"
       else
         "none"
       end
     end
 
-    sig { returns(String) }
-    def detect_test_library
-      if direct_dependency?(/^rspec/)
+    # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
+    # single linter. To have multiple linters running, the user must configure them manually
+    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies)
+      linters = []
+      linters << "rubocop" if dependencies.any?(/^rubocop/)
+      linters
+    end
+
+    sig { params(dependencies: T::Array[String]).returns(String) }
+    def detect_test_library(dependencies)
+      if dependencies.any?(/^rspec/)
         "rspec"
       # 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. A Rails app doesn't need to depend on the rails gem itself, individual components like
@@ -110,23 +135,23 @@ module RubyLsp
       elsif File.exist?(File.join(workspace_path, "bin/rails"))
         "rails"
       # NOTE: Intentionally ends with $ to avoid mis-matching minitest-reporters, etc. in a Rails app.
-      elsif direct_dependency?(/^minitest$/)
+      elsif dependencies.any?(/^minitest$/)
         "minitest"
-      elsif direct_dependency?(/^test-unit/)
+      elsif dependencies.any?(/^test-unit/)
         "test-unit"
       else
         "unknown"
       end
     end
 
-    sig { returns(T::Boolean) }
-    def detect_typechecker
+    sig { params(dependencies: T::Array[String]).returns(T::Boolean) }
+    def detect_typechecker(dependencies)
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
       # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
       ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
       Bundler.with_original_env do
-        sorbet_static_detected = Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        sorbet_static_detected = dependencies.any?(/^sorbet-static/)
         # Don't show message while running tests, since it's noisy
         if sorbet_static_detected && !ruby_lsp_env_is_test
           $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
@@ -138,16 +163,11 @@ module RubyLsp
     end
 
     sig { returns(T::Array[String]) }
-    def dependencies
-      @dependencies ||= T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_gemfile }
-          Bundler.locked_gems.dependencies.keys + gemspec_dependencies
-        rescue Bundler::GemfileNotFound
-          []
-        end,
-        T.nilable(T::Array[String]),
-      )
+    def gather_dependencies
+      Bundler.with_original_env { Bundler.default_gemfile }
+      Bundler.locked_gems.dependencies.keys + gemspec_dependencies
+    rescue Bundler::GemfileNotFound
+      []
     end
 
     sig { returns(T::Array[String]) }

data/lib/ruby_lsp/listeners/definition.rb

@@ -7,6 +7,8 @@ module RubyLsp
       extend T::Sig
       include Requests::Support::Common
 
+      MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 10
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
@@ -64,12 +66,17 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def handle_method_definition(node)
-        return unless self_receiver?(node)
-
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @nesting.join("::"))
+        methods = if self_receiver?(node)
+          @index.resolve_method(message, @nesting.join("::"))
+        else
+          # If the method doesn't have a receiver, then we provide a few candidates to jump to
+          # But we don't want to provide too many candidates, as it can be overwhelming
+          @index[message]&.take(MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER)
+        end
+
         return unless methods
 
         methods.each do |target_method|

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -34,7 +34,7 @@ module RubyLsp
       sig { params(global_state: GlobalState, document: Document).void }
       def initialize(global_state, document)
         super()
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+        @active_linters = T.let(global_state.active_linters, T::Array[Support::Formatter])
         @document = document
         @uri = T.let(document.uri, URI::Generic)
       end
@@ -45,10 +45,13 @@ module RubyLsp
         diagnostics.concat(syntax_error_diagnostics, syntax_warning_diagnostics)
 
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
-        return diagnostics if @document.syntax_error? || !@active_formatter
+        return diagnostics if @document.syntax_error? || @active_linters.empty?
+
+        @active_linters.each do |linter|
+          linter_diagnostics = linter.run_diagnostic(@uri, @document)
+          diagnostics.concat(linter_diagnostics) if linter_diagnostics
+        end
 
-        formatter_diagnostics = @active_formatter.run_diagnostic(@uri, @document)
-        diagnostics.concat(formatter_diagnostics) if formatter_diagnostics
         diagnostics
       end
 

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -40,10 +40,13 @@ module RubyLsp
         end
       end
 
-      sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
-      def initialize(dispatcher, range: nil)
+      sig { params(global_state: GlobalState, dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
+      def initialize(global_state, dispatcher, range: nil)
         super()
-        @response_builder = T.let(ResponseBuilders::SemanticHighlighting.new, ResponseBuilders::SemanticHighlighting)
+        @response_builder = T.let(
+          ResponseBuilders::SemanticHighlighting.new(global_state.encoding),
+          ResponseBuilders::SemanticHighlighting,
+        )
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder, range: range)
 
         Addon.addons.each do |addon|

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

@@ -3,15 +3,12 @@
 
 return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
-require "singleton"
-
 module RubyLsp
   module Requests
     module Support
       class RuboCopFormatter
         extend T::Sig
         include Formatter
-        include Singleton
 
         sig { void }
         def initialize

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

@@ -8,15 +8,12 @@ rescue LoadError
   return
 end
 
-require "singleton"
-
 module RubyLsp
   module Requests
     module Support
       # :nodoc:
       class SyntaxTreeFormatter
         extend T::Sig
-        include Singleton
         include Support::Formatter
 
         sig { void }

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -55,19 +55,21 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig { void }
-      def initialize
-        super
+      sig { params(encoding: Encoding).void }
+      def initialize(encoding)
+        super()
+        @encoding = encoding
         @stack = T.let([], T::Array[SemanticToken])
       end
 
       sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
-        length = location.end_offset - location.start_offset
+        length = location.end_code_units_offset(@encoding) - location.start_code_units_offset(@encoding)
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
         @stack.push(
           SemanticToken.new(
-            location: location,
+            start_line: location.start_line,
+            start_code_unit_column: location.start_code_units_column(@encoding),
             length: length,
             type: T.must(TOKEN_TYPES[type]),
             modifier: modifiers_indices,
@@ -75,6 +77,15 @@ module RubyLsp
         )
       end
 
+      sig { params(location: Prism::Location).returns(T::Boolean) }
+      def last_token_matches?(location)
+        token = @stack.last
+        return false unless token
+
+        token.start_line == location.start_line &&
+          token.start_code_unit_column == location.start_code_units_column(@encoding)
+      end
+
       sig { returns(T.nilable(SemanticToken)) }
       def last
         @stack.last
@@ -88,8 +99,11 @@ module RubyLsp
       class SemanticToken
         extend T::Sig
 
-        sig { returns(Prism::Location) }
-        attr_reader :location
+        sig { returns(Integer) }
+        attr_reader :start_line
+
+        sig { returns(Integer) }
+        attr_reader :start_code_unit_column
 
         sig { returns(Integer) }
         attr_reader :length
@@ -100,9 +114,18 @@ module RubyLsp
         sig { returns(T::Array[Integer]) }
         attr_reader :modifier
 
-        sig { params(location: Prism::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
-        def initialize(location:, length:, type:, modifier:)
-          @location = location
+        sig do
+          params(
+            start_line: Integer,
+            start_code_unit_column: Integer,
+            length: Integer,
+            type: Integer,
+            modifier: T::Array[Integer],
+          ).void
+        end
+        def initialize(start_line:, start_code_unit_column:, length:, type:, modifier:)
+          @start_line = start_line
+          @start_code_unit_column = start_code_unit_column
           @length = length
           @type = type
           @modifier = modifier
@@ -146,7 +169,7 @@ module RubyLsp
             # Enumerable#sort_by is not deterministic when the compared values are equal.
             # When that happens, we need to use the index as a tie breaker to ensure
             # that the order of the tokens is always the same.
-            [token.location.start_line, token.location.start_column, index]
+            [token.start_line, token.start_code_unit_column, index]
           end
 
           delta = sorted_tokens.flat_map do |token|
@@ -167,8 +190,8 @@ module RubyLsp
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
         sig { params(token: SemanticToken).returns(T::Array[Integer]) }
         def compute_delta(token)
-          row = token.location.start_line - 1
-          column = token.location.start_column
+          row = token.start_line - 1
+          column = token.start_code_unit_column
 
           begin
             delta_line = row - @current_row

data/lib/ruby_lsp/server.rb

@@ -187,11 +187,8 @@ module RubyLsp
 
       send_message(Result.new(id: message[:id], response: response))
 
-      # Dynamically registered capabilities
-      file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
-
       # Not every client supports dynamic registration or file watching
-      if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+      if global_state.supports_watching_files
         send_message(
           Request.new(
             id: @current_request_id,
@@ -248,10 +245,10 @@ module RubyLsp
       end
 
       if defined?(Requests::Support::RuboCopFormatter)
-        @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.instance)
+        @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
       end
       if defined?(Requests::Support::SyntaxTreeFormatter)
-        @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.instance)
+        @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
       end
 
       perform_initial_indexing(indexing_config)
@@ -337,7 +334,7 @@ module RubyLsp
       document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
 
-      semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
+      semantic_highlighting = Requests::SemanticHighlighting.new(@global_state, dispatcher)
       dispatcher.dispatch(document.tree)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -369,7 +366,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      request = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
+      request = Requests::SemanticHighlighting.new(@global_state, dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
       response = request.perform
@@ -613,6 +610,7 @@ module RubyLsp
         uri = URI(change[:uri])
         file_path = uri.to_standardized_path
         next if file_path.nil? || File.directory?(file_path)
+        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)

data/lib/ruby_lsp/utils.rb

@@ -75,7 +75,7 @@ module RubyLsp
   class Request < Message
     extend T::Sig
 
-    sig { params(id: Integer, method: String, params: Object).void }
+    sig { params(id: T.any(Integer, String), method: String, params: Object).void }
     def initialize(id:, method:, params:)
       @id = id
       super(method: method, params: params)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.16.5
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-09 00:00:00.000000000 Z
+date: 2024-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.23.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.28'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -83,6 +83,7 @@ files:
 - 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/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
@@ -177,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.7
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby