ruby-lsp 0.24.1 → 0.25.0

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -365,7 +365,7 @@ module RubyLsp
           end
         end
 
-        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode # rubocop:disable Layout/LineLength
+        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode
 
         node_context = @document.locate_node(
           {

data/lib/ruby_lsp/requests/code_lens.rb

@@ -27,10 +27,16 @@ module RubyLsp
         @document = document
         @test_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
         uri = document.uri
+        file_path = uri.full_path
+        code_lens_config = global_state.feature_configuration(:codeLens)
+        test_lenses_enabled = (!code_lens_config || code_lens_config.enabled?(:enableTestCodeLens)) &&
+          file_path && File.fnmatch?(TEST_PATH_PATTERN, file_path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
 
         if global_state.enabled_feature?(:fullTestDiscovery)
-          Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
-          Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+          if test_lenses_enabled
+            Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
+            Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+          end
         else
           Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
         end
@@ -38,7 +44,7 @@ module RubyLsp
         Addon.addons.each do |addon|
           addon.create_code_lens_listener(@response_builder, uri, dispatcher)
 
-          if global_state.enabled_feature?(:fullTestDiscovery)
+          if global_state.enabled_feature?(:fullTestDiscovery) && test_lenses_enabled
             addon.create_discover_tests_listener(@test_builder, dispatcher, uri)
           end
         end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -16,13 +16,13 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
-      def initialize(document, hints_configuration, dispatcher)
+      #: (GlobalState, (RubyDocument | ERBDocument), Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
         super()
 
         @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
-        Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
+        Listeners::InlayHints.new(global_state, @response_builder, dispatcher)
       end
 
       # @override

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -162,7 +162,7 @@ module RubyLsp
 
       #: (Integer line, Integer character) -> void
       def move_cursor_to(line, character)
-        return unless /Visual Studio Code|Cursor|VSCodium/.match?(@client_name)
+        return unless /Visual Studio Code|Cursor|VSCodium|Windsurf/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,

data/lib/ruby_lsp/requests/references.rb

@@ -55,7 +55,7 @@ module RubyLsp
           )
         end
 
-        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode, # rubocop:disable Layout/LineLength
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode,
 
         reference_target = create_reference_target(target, node_context)
         return @locations unless reference_target

data/lib/ruby_lsp/requests/request.rb

@@ -9,7 +9,9 @@ module RubyLsp
 
       # @abstract
       #: -> untyped
-      def perform; end
+      def perform
+        raise AbstractMethodInvokedError
+      end
 
       private
 

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

@@ -9,15 +9,21 @@ module RubyLsp
       module Formatter
         # @abstract
         #: (URI::Generic, RubyLsp::RubyDocument) -> String?
-        def run_formatting(uri, document); end
+        def run_formatting(uri, document)
+          raise AbstractMethodInvokedError
+        end
 
         # @abstract
         #: (URI::Generic, String, Integer) -> String?
-        def run_range_formatting(uri, source, base_indentation); end
+        def run_range_formatting(uri, source, base_indentation)
+          raise AbstractMethodInvokedError
+        end
 
         # @abstract
         #: (URI::Generic, RubyLsp::RubyDocument) -> Array[Interface::Diagnostic]?
-        def run_diagnostic(uri, document); end
+        def run_diagnostic(uri, document)
+          raise AbstractMethodInvokedError
+        end
       end
     end
   end

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

@@ -24,7 +24,7 @@ module RubyLsp
           filename = uri.to_standardized_path || uri.opaque #: as !nil
 
           # Invoke RuboCop with just this file in `paths`
-          @format_runner.run(filename, document.source)
+          @format_runner.run(filename, document.source, document.parse_result)
           @format_runner.formatted_source
         end
 
@@ -40,7 +40,7 @@ module RubyLsp
         def run_diagnostic(uri, document)
           filename = uri.to_standardized_path || uri.opaque #: as !nil
           # Invoke RuboCop with just this file in `paths`
-          @diagnostic_runner.run(filename, document.source)
+          @diagnostic_runner.run(filename, document.source, document.parse_result)
 
           @diagnostic_runner.offenses.map do |offense|
             Support::RuboCopDiagnostic.new(

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

@@ -81,6 +81,7 @@ module RubyLsp
           @offenses = [] #: Array[::RuboCop::Cop::Offense]
           @errors = [] #: Array[String]
           @warnings = [] #: Array[String]
+          @prism_result = nil #: Prism::ParseLexResult?
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
@@ -92,14 +93,15 @@ module RubyLsp
           super(rubocop_options, config_store)
         end
 
-        #: (String path, String contents) -> void
-        def run(path, contents)
+        #: (String, String, Prism::ParseLexResult) -> void
+        def run(path, contents, prism_result)
           # Clear Runner state between runs since we get a single instance of this class
           # on every use site.
           @errors = []
           @warnings = []
           @offenses = []
           @options[:stdin] = contents
+          @prism_result = prism_result
 
           super([path])
 
@@ -111,7 +113,11 @@ module RubyLsp
         rescue ::RuboCop::ValidationError => error
           raise ConfigurationError, error.message
         rescue StandardError => error
-          raise InternalRuboCopError, error
+          # Maintain the original backtrace so that debugging cops that are breaking is easier, but re-raise as a
+          # different error class
+          internal_error = InternalRuboCopError.new(error)
+          internal_error.set_backtrace(error.backtrace)
+          raise internal_error
         end
 
         #: -> String

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -5,11 +5,11 @@ module RubyLsp
   module ResponseBuilders
     # @abstract
     class ResponseBuilder
-      extend T::Generic
-
       # @abstract
       #: -> top
-      def response; end
+      def response
+        raise AbstractMethodInvokedError
+      end
     end
   end
 end

data/lib/ruby_lsp/ruby_document.rb

@@ -26,7 +26,7 @@ module RubyLsp
         queue = node.child_nodes.compact #: Array[Prism::Node?]
         closest = node
         parent = nil #: Prism::Node?
-        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)] # rubocop:disable Layout/LineLength
+        nesting_nodes = [] #: Array[(Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode | Prism::DefNode | Prism::BlockNode | Prism::LambdaNode | Prism::ProgramNode)]
 
         nesting_nodes << node if node.is_a?(Prism::ProgramNode)
         call_node = nil #: Prism::CallNode?

data/lib/ruby_lsp/server.rb

@@ -94,7 +94,13 @@ module RubyLsp
             id: message[:id],
             response:
               Addon.addons.map do |addon|
-                { name: addon.name, version: addon.version, errored: addon.error? }
+                version = begin
+                  addon.version
+                rescue AbstractMethodInvokedError
+                  nil
+                end
+
+                { name: addon.name, version: version, errored: addon.error? }
               end,
           ),
         )
@@ -115,7 +121,7 @@ module RubyLsp
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
-    rescue StandardError, LoadError => e
+    rescue StandardError, LoadError, SystemExit => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
         # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
@@ -203,10 +209,6 @@ module RubyLsp
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
-      configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
-      @store.features_configuration.dig(:inlayHint) #: as !nil
-        .configuration.merge!(configured_hints) if configured_hints
-
       enabled_features = case configured_features
       when Array
         # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
@@ -360,6 +362,7 @@ module RubyLsp
 
       perform_initial_indexing
       check_formatter_is_available
+      update_server if @global_state.enabled_feature?(:launcher)
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -473,8 +476,8 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       inlay_hint = Requests::InlayHints.new(
+        @global_state,
         document,
-        @store.features_configuration.dig(:inlayHint), #: as !nil
         dispatcher,
       )
 
@@ -821,7 +824,6 @@ module RubyLsp
         return
       end
 
-      hints_configurations = @store.features_configuration.dig(:inlayHint) #: as !nil
       dispatcher = Prism::Dispatcher.new
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
@@ -829,7 +831,7 @@ module RubyLsp
         return
       end
 
-      request = Requests::InlayHints.new(document, hints_configurations, dispatcher)
+      request = Requests::InlayHints.new(@global_state, document, dispatcher)
       dispatcher.visit(document.ast)
       result = request.perform
       document.cache_set("textDocument/inlayHint", result)
@@ -1405,8 +1407,38 @@ module RubyLsp
 
       # We compose the bundle in a thread so that the LSP continues to work while we're checking for its validity. Once
       # we return the response back to the editor, then the restart is triggered
+      launch_bundle_compose("Recomposing the bundle ahead of restart") do |stderr, status|
+        if status&.exitstatus == 0
+          # Create a signal for the restart that it can skip composing the bundle and launch directly
+          FileUtils.touch(already_composed_path)
+          send_message(Result.new(id: id, response: { success: true }))
+        else
+          # This special error code makes the extension avoid restarting in case we already know that the composed
+          # bundle is not valid
+          send_message(
+            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
+          )
+        end
+      end
+    end
+
+    #: -> void
+    def update_server
+      return unless File.exist?(File.join(@global_state.workspace_path, ".ruby-lsp", "needs_update"))
+
+      launch_bundle_compose("Trying to update server") do |stderr, status|
+        if status&.exitstatus == 0
+          send_log_message("Successfully updated the server")
+        else
+          send_log_message("Failed to update server\n#{stderr}", type: Constant::MessageType::ERROR)
+        end
+      end
+    end
+
+    #: (String) { (IO, Process::Status?) -> void } -> Thread
+    def launch_bundle_compose(log, &block)
       Thread.new do
-        send_log_message("Recomposing the bundle ahead of restart")
+        send_log_message(log)
 
         _stdout, stderr, status = Bundler.with_unbundled_env do
           Open3.capture3(
@@ -1421,17 +1453,7 @@ module RubyLsp
           )
         end
 
-        if status&.exitstatus == 0
-          # Create a signal for the restart that it can skip composing the bundle and launch directly
-          FileUtils.touch(already_composed_path)
-          send_message(Result.new(id: id, response: { success: true }))
-        else
-          # This special error code makes the extension avoid restarting in case we already know that the composed
-          # bundle is not valid
-          send_message(
-            Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle\n#{stderr}"),
-          )
-        end
+        block.call(stderr, status)
       end
     end
 

data/lib/ruby_lsp/setup_bundler.rb

@@ -1,7 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "bundler"
 require "bundler/cli"
 require "bundler/cli/install"
@@ -20,11 +19,16 @@ Bundler.ui.level = :silent
 
 module RubyLsp
   class SetupBundler
-    extend T::Sig
-
     class BundleNotLocked < StandardError; end
     class BundleInstallFailure < StandardError; end
 
+    module ThorPatch
+      #: -> IO
+      def stdout
+        $stderr
+      end
+    end
+
     FOUR_HOURS = 4 * 60 * 60 #: Integer
 
     #: (String project_path, **untyped options) -> void
@@ -61,6 +65,7 @@ module RubyLsp
       @bundler_version = bundler_version #: Gem::Version?
       @rails_app = rails_app? #: bool
       @retry = false #: bool
+      @needs_update_path = @custom_dir + "needs_update" #: Pathname
     end
 
     # Sets up the composed bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
@@ -256,19 +261,50 @@ module RubyLsp
     #: (Hash[String, String] env, ?force_install: bool) -> Hash[String, String]
     def run_bundle_install_directly(env, force_install: false)
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
+      return update(env) if @needs_update_path.exist?
 
       # 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?
-      ENV #: as untyped
-        .merge!(env)
+      FileUtils.touch(@needs_update_path) if should_bundle_update?
+      ENV.merge!(env)
 
-      unless should_update && !force_install
-        Bundler::CLI::Install.new({ "no-cache" => true }).run
-        correct_relative_remote_paths if @custom_lockfile.exist?
-        return env
+      $stderr.puts("Ruby LSP> Checking if the composed bundle is satisfied...")
+      missing_gems = bundle_check
+
+      unless missing_gems.empty?
+        $stderr.puts(<<~MESSAGE)
+          Ruby LSP> Running bundle install because the following gems are not installed:
+          #{missing_gems.map { |g| "#{g.name}: #{g.version}" }.join("\n")}
+        MESSAGE
+
+        bundle_install
       end
 
+      $stderr.puts("Ruby LSP> Bundle already satisfied")
+      env
+    rescue => e
+      $stderr.puts("Ruby LSP> Running bundle install because #{e.message}")
+      bundle_install
+      env
+    end
+
+    # Essentially the same as bundle check, but simplified
+    #: -> Array[Gem::Specification]
+    def bundle_check
+      definition = Bundler.definition
+      definition.validate_runtime!
+      definition.check!
+      definition.missing_specs
+    end
+
+    #: -> void
+    def bundle_install
+      Bundler::CLI::Install.new({ "no-cache" => true }).run
+      correct_relative_remote_paths if @custom_lockfile.exist?
+    end
+
+    #: (Hash[String, String]) -> Hash[String, String]
+    def update(env)
       # 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] }
@@ -276,11 +312,9 @@ module RubyLsp
 
       Bundler::CLI::Update.new({ conservative: true }, gems).run
       correct_relative_remote_paths if @custom_lockfile.exist?
+      @needs_update_path.delete
       @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
 
     #: (Hash[String, String] env) -> Hash[String, String]
@@ -440,15 +474,7 @@ module RubyLsp
     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::Thor::Shell::Basic.prepend(ThorPatch)
       Bundler.ui.level = :info
     end
   end

data/lib/ruby_lsp/static_docs.rb

@@ -14,6 +14,7 @@ module RubyLsp
 
   # A map of keyword => short documentation to be displayed on hover or completion
   KEYWORD_DOCS = {
+    "break" => "Terminates the execution of a block or loop",
     "yield" => "Invokes the passed block with the given arguments",
   }.freeze #: Hash[String, String]
 end

data/lib/ruby_lsp/store.rb

@@ -5,9 +5,6 @@ module RubyLsp
   class Store
     class NonExistingDocumentError < StandardError; end
 
-    #: Hash[Symbol, RequestConfig]
-    attr_accessor :features_configuration
-
     #: String
     attr_accessor :client_name
 
@@ -15,13 +12,6 @@ module RubyLsp
     def initialize(global_state)
       @global_state = global_state
       @state = {} #: Hash[String, Document[untyped]]
-      @features_configuration = {
-        inlayHint: RequestConfig.new({
-          enableAll: false,
-          implicitRescue: false,
-          implicitHashValue: false,
-        }),
-      } #: Hash[Symbol, RequestConfig]
       @client_name = "Unknown" #: String
     end
 

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -12,6 +12,18 @@ module RubyLsp
   class LspReporter
     include Singleton
 
+    # https://code.visualstudio.com/api/references/vscode-api#Position
+    #: type position = { line: Integer, character: Integer }
+
+    # https://code.visualstudio.com/api/references/vscode-api#Range
+    #: type range = { start: position, end: position }
+
+    # https://code.visualstudio.com/api/references/vscode-api#BranchCoverage
+    #: type branch_coverage = { executed: Integer, label: String, location: range }
+
+    # https://code.visualstudio.com/api/references/vscode-api#StatementCoverage
+    #: type statement_coverage = { executed: Integer, location: position, branches: Array[branch_coverage] }
+
     #: bool
     attr_reader :invoked_shutdown
 
@@ -20,8 +32,6 @@ module RubyLsp
       dir_path = File.join(Dir.tmpdir, "ruby-lsp")
       FileUtils.mkdir_p(dir_path)
 
-      # Remove in 1 month once updates have rolled out
-      legacy_port_path = File.join(dir_path, "test_reporter_port")
       port_db_path = File.join(dir_path, "test_reporter_port_db.json")
       port = ENV["RUBY_LSP_REPORTER_PORT"]
 
@@ -32,8 +42,6 @@ module RubyLsp
         elsif File.exist?(port_db_path)
           db = JSON.load_file(port_db_path)
           TCPSocket.new("localhost", db[Dir.pwd])
-        elsif File.exist?(legacy_port_path)
-          TCPSocket.new("localhost", File.read(legacy_port_path))
         else
           # For tests that don't spawn the TCP server
           require "stringio"
@@ -129,7 +137,7 @@ module RubyLsp
     #       ["Foo", :bar, 6, 21, 6, 65] => 0
     #     }
     # }
-    #: -> Hash[String, StatementCoverage]
+    #: -> Hash[String, statement_coverage]
     def gather_coverage_results
       # Ignore coverage results inside dependencies
       bundle_path = Bundler.bundle_path.to_s

data/lib/ruby_lsp/test_reporters/minitest_reporter.rb

@@ -74,12 +74,25 @@ module RubyLsp
       end
     end
 
-    #: (singleton(Minitest::Test) test_class, String method_name) -> void
-    def prerecord(test_class, method_name)
-      uri, line = LspReporter.instance.uri_and_line_for(test_class.instance_method(method_name))
+    #: (untyped, String) -> void
+    def prerecord(test_class_or_wrapper, method_name)
+      # In frameworks like Rails, they can control the Minitest execution by wrapping the test class
+      # But they conform to responding to `name`, so we can use that as a guarantee
+      # We are interested in the test class, not the wrapper
+      name = test_class_or_wrapper.name
+
+      klass = begin
+        Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
+      rescue NameError
+        # Handle Minitest specs that create classes with invalid constant names like "MySpec::when something is true"
+        # If we can't resolve the constant, it means we were given the actual test class object, not the wrapper
+        test_class_or_wrapper
+      end
+
+      uri, line = LspReporter.instance.uri_and_line_for(klass.instance_method(method_name))
       return unless uri
 
-      id = "#{test_class.name}##{handle_spec_test_id(method_name, line)}"
+      id = "#{name}##{handle_spec_test_id(method_name, line)}"
       LspReporter.instance.start_test(id: id, uri: uri, line: line)
     end
 

data/lib/ruby_lsp/utils.rb

@@ -5,7 +5,6 @@ module RubyLsp
   # rubocop:disable RubyLsp/UseLanguageServerAliases
   Interface = LanguageServer::Protocol::Interface
   Constant = LanguageServer::Protocol::Constant
-  Transport = LanguageServer::Protocol::Transport
   # rubocop:enable RubyLsp/UseLanguageServerAliases
 
   # Used to indicate that a request shouldn't return a response
@@ -20,6 +19,7 @@ module RubyLsp
     "Gemfile"
   end #: String
   GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/#guessed-types"
+  TEST_PATH_PATTERN = "**/{test,spec,features}/**/{*_test.rb,test_*.rb,*_spec.rb,*.feature}"
 
   # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
   # use this custom error class as a way to return a signal to the client that the request should be delegated to the
@@ -31,6 +31,8 @@ module RubyLsp
     CODE = -32900
   end
 
+  class AbstractMethodInvokedError < StandardError; end
+
   BUNDLE_COMPOSE_FAILED_CODE = -33000
 
   # A notification to be sent to the client
@@ -50,7 +52,9 @@ module RubyLsp
 
     # @abstract
     #: -> Hash[Symbol, untyped]
-    def to_hash; end
+    def to_hash
+      raise AbstractMethodInvokedError
+    end
   end
 
   class Notification < Message
@@ -243,9 +247,6 @@ module RubyLsp
 
   # A request configuration, to turn on/off features
   class RequestConfig
-    #: Hash[Symbol, bool]
-    attr_accessor :configuration
-
     #: (Hash[Symbol, bool] configuration) -> void
     def initialize(configuration)
       @configuration = configuration
@@ -255,6 +256,11 @@ module RubyLsp
     def enabled?(feature)
       @configuration[:enableAll] || @configuration[feature]
     end
+
+    #: (Hash[Symbol, bool]) -> void
+    def merge!(hash)
+      @configuration.merge!(hash)
+    end
   end
 
   class SorbetLevel
@@ -299,4 +305,37 @@ module RubyLsp
     #: -> bool
     def true_or_higher? = @level == :true || @level == :strict
   end
+
+  # Reads JSON RPC messages from the given IO in a loop
+  class MessageReader
+    #: (IO) -> void
+    def initialize(io)
+      @io = io
+    end
+
+    #: () { (Hash[Symbol, untyped]) -> void } -> void
+    def each_message(&block)
+      while (headers = @io.gets("\r\n\r\n"))
+        raw_message = @io.read(headers[/Content-Length: (\d+)/i, 1].to_i) #: as !nil
+        block.call(JSON.parse(raw_message, symbolize_names: true))
+      end
+    end
+  end
+
+  # Writes JSON RPC messages to the given IO
+  class MessageWriter
+    #: (IO) -> void
+    def initialize(io)
+      @io = io
+    end
+
+    #: (Hash[Symbol, untyped]) -> void
+    def write(message)
+      message[:jsonrpc] = "2.0"
+      json_message = message.to_json
+
+      @io.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+      @io.flush
+    end
+  end
 end