ruby-lsp 0.15.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9749ddfd5f25d0f6e3c0636a070d8977c19af973943e33deba4e49cba9b473d6
-  data.tar.gz: 1c3f663fd6487e8517154a2595be253659e2f2f9bd6a4df23c8b16a91e159c4d
+  metadata.gz: b52249bb9ff4600edc041d0ac28d961c7670f5dad2475b632fa5ea87c02e1657
+  data.tar.gz: c15ed4c4cd012c64f526ce3c31ca0f70a248467a44034dc6ffeed50cda94d9ad
 SHA512:
-  metadata.gz: '039fc58aa31af82930cc2852819208fdd9045ed493cf368702f87e9ffd814487bf63fe522124fa3210336cfc72d806b828e2e338114a66913dbd688ed85980c3'
-  data.tar.gz: bb4d62e3ce21fe07cda085f0284b69c356a10694125454b8160bd0c5e87789481b2d4f8036cdb4cdc2b0667c8a78c7e7a1409307722a532122172fcff8c5450c
+  metadata.gz: bf9936e23669e947cc802e5efe4fc5466528dff0e290d3daf255522cdca7e41d08802737da2f93b0690ca3abf3916a726926b454964f21a67bb661e902494390
+  data.tar.gz: 6d6b39a1dfe90b54e4e20a1a4eda471a71418b85c94ee305c5e9b1a77be8251a304d0da9f4c72fae28773e14bdb1f316da12ce41ef436c2bc72d78903a647fb1

data/README.md

@@ -29,7 +29,7 @@ The Ruby LSP features include
 - Debugging support
 - Running and debugging tests through VS Code's UI
 - Go to definition for classes, modules, constants and required files
-- Showing documentaton on hover for classes, modules and constants
+- Showing documentation on hover for classes, modules and constants
 - Completion for classes, modules, constants and require paths
 - Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
 

data/VERSION

@@ -1 +1 @@
-0.15.0
+0.16.1

data/exe/ruby-lsp-doctor

@@ -4,6 +4,15 @@
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
+if File.exist?(".index.yml")
+  begin
+    config = YAML.parse_file(".index.yml").to_ruby
+  rescue => e
+    abort("Error parsing config: #{e.message}")
+  end
+  RubyIndexer.configuration.apply_config(config)
+end
+
 index = RubyIndexer::Index.new
 
 puts "Globbing for indexable files"

data/lib/ruby_indexer/lib/ruby_indexer/collector.rb

@@ -154,6 +154,8 @@ module RubyIndexer
         handle_attribute(node, reader: true, writer: true)
       when :include
         handle_include(node)
+      when :prepend
+        handle_prepend(node)
       end
     end
 
@@ -355,6 +357,16 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_include(node)
+      handle_module_operation(node, :included_modules)
+    end
+
+    sig { params(node: Prism::CallNode).void }
+    def handle_prepend(node)
+      handle_module_operation(node, :prepended_modules)
+    end
+
+    sig { params(node: Prism::CallNode, operation: Symbol).void }
+    def handle_module_operation(node, operation)
       return unless @current_owner
 
       arguments = node.arguments&.arguments
@@ -369,7 +381,8 @@ module RubyIndexer
         # If a constant path reference is dynamic or missing parts, we can't
         # index it
       end
-      @current_owner.included_modules.concat(names)
+      collection = operation == :included_modules ? @current_owner.included_modules : @current_owner.prepended_modules
+      collection.concat(names)
     end
   end
 end

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

@@ -43,6 +43,9 @@ module RubyIndexer
       sig { returns(T::Array[String]) }
       attr_accessor :included_modules
 
+      sig { returns(T::Array[String]) }
+      attr_accessor :prepended_modules
+
       sig do
         params(
           name: String,
@@ -54,6 +57,7 @@ module RubyIndexer
       def initialize(name, file_path, location, comments)
         super(name, file_path, location, comments)
         @included_modules = T.let([], T::Array[String])
+        @prepended_modules = T.let([], T::Array[String])
       end
 
       sig { returns(String) }

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -327,5 +327,51 @@ module RubyIndexer
       constant_path_references = T.must(@index["ConstantPathReferences"][0])
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.included_modules)
     end
+
+    def test_keeping_track_of_prepended_modules
+      index(<<~RUBY)
+        class Foo
+          # valid syntaxes that we can index
+          prepend A1
+          self.prepend A2
+          prepend A3, A4
+          self.prepend A5, A6
+
+          # valid syntaxes that we cannot index because of their dynamic nature
+          prepend some_variable_or_method_call
+          self.prepend some_variable_or_method_call
+
+          def something
+            prepend A7 # We should not index this because of this dynamic nature
+          end
+
+          # Valid inner class syntax definition with its own modules prepended
+          class Qux
+            prepend Corge
+            self.prepend Corge
+            prepend Baz
+
+            prepend some_variable_or_method_call
+          end
+        end
+
+        class ConstantPathReferences
+          prepend Foo::Bar
+          self.prepend Foo::Bar2
+
+          prepend dynamic::Bar
+          prepend Foo::
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"][0])
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.prepended_modules)
+
+      qux = T.must(@index["Foo::Qux"][0])
+      assert_equal(["Corge", "Corge", "Baz"], qux.prepended_modules)
+
+      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.prepended_modules)
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -50,8 +50,8 @@ module RubyLsp
       end
 
       # Discovers and loads all addons. Returns the list of activated addons
-      sig { params(message_queue: Thread::Queue).returns(T::Array[Addon]) }
-      def load_addons(message_queue)
+      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[Addon]) }
+      def load_addons(global_state, outgoing_queue)
         # Require all addons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
         Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
@@ -67,7 +67,7 @@ module RubyLsp
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
         addons.each do |addon|
-          addon.activate(message_queue)
+          addon.activate(global_state, outgoing_queue)
         rescue => e
           addon.add_error(e)
         end
@@ -105,8 +105,8 @@ module RubyLsp
 
     # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(message_queue: Thread::Queue).void }
-    def activate(message_queue); end
+    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+    def activate(global_state, outgoing_queue); end
 
     # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
@@ -121,23 +121,21 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-        global_state: GlobalState,
         uri: URI::Generic,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_code_lens_listener(response_builder, global_state, uri, dispatcher); end
+    def create_code_lens_listener(response_builder, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
       overridable.params(
         response_builder: ResponseBuilders::Hover,
-        global_state: GlobalState,
         nesting: T::Array[String],
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_hover_listener(response_builder, global_state, nesting, dispatcher); end
+    def create_hover_listener(response_builder, nesting, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
@@ -160,24 +158,22 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
-        global_state: GlobalState,
         uri: URI::Generic,
         nesting: T::Array[String],
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_definition_listener(response_builder, global_state, uri, nesting, dispatcher); end
+    def create_definition_listener(response_builder, uri, nesting, dispatcher); end
 
     # Creates a new Completion listener. This method is invoked on every Completion request
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-        global_state: GlobalState,
         nesting: T::Array[String],
         dispatcher: Prism::Dispatcher,
         uri: URI::Generic,
       ).void
     end
-    def create_completion_listener(response_builder, global_state, nesting, dispatcher, uri); end
+    def create_completion_listener(response_builder, nesting, dispatcher, uri); end
   end
 end

data/lib/ruby_lsp/global_state.rb

@@ -25,6 +25,17 @@ module RubyLsp
       @test_library = T.let(detect_test_library, String)
       @typechecker = T.let(detect_typechecker, T::Boolean)
       @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
+    end
+
+    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    def register_formatter(identifier, instance)
+      @supported_formatters[identifier] = instance
+    end
+
+    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    def active_formatter
+      @supported_formatters[@formatter]
     end
 
     sig { params(options: T::Hash[Symbol, T.untyped]).void }
@@ -52,17 +63,17 @@ module RubyLsp
 
     sig { returns(String) }
     def detect_test_library
+      if direct_dependency?(/^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.
-      if direct_dependency?(/^rails$/)
+      elsif 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

data/lib/ruby_lsp/internal.rb

@@ -34,3 +34,5 @@ require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+require "ruby_lsp/requests/support/rubocop_formatter"
+require "ruby_lsp/requests/support/syntax_tree_formatter"

data/lib/ruby_lsp/requests/code_lens.rb

@@ -48,7 +48,7 @@ module RubyLsp
         Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
 
         Addon.addons.each do |addon|
-          addon.create_code_lens_listener(@response_builder, global_state, uri, dispatcher)
+          addon.create_code_lens_listener(@response_builder, uri, dispatcher)
         end
       end
 

data/lib/ruby_lsp/requests/completion.rb

@@ -78,7 +78,7 @@ module RubyLsp
         )
 
         Addon.addons.each do |addon|
-          addon.create_completion_listener(@response_builder, global_state, nesting, dispatcher, document.uri)
+          addon.create_completion_listener(@response_builder, nesting, dispatcher, document.uri)
         end
 
         return unless matched && parent

data/lib/ruby_lsp/requests/definition.rb

@@ -67,7 +67,7 @@ module RubyLsp
         )
 
         Addon.addons.each do |addon|
-          addon.create_definition_listener(@response_builder, global_state, document.uri, nesting, dispatcher)
+          addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
         end
 
         @target = T.let(target, T.nilable(Prism::Node))

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
-
 module RubyLsp
   module Requests
     # ![Diagnostics demo](../../diagnostics.gif)
@@ -33,9 +31,10 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document).void }
-      def initialize(document)
+      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))
         @document = document
         @uri = T.let(document.uri, URI::Generic)
       end
@@ -46,15 +45,10 @@ 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?
-
-        diagnostics.concat(
-          Support::RuboCopDiagnosticsRunner.instance.run(
-            @uri,
-            @document,
-          ).map!(&:to_lsp_diagnostic),
-        ) if defined?(Support::RuboCopDiagnosticsRunner)
+        return diagnostics if @document.syntax_error? || !@active_formatter
 
+        formatter_diagnostics = @active_formatter.run_diagnostic(@uri, @document)
+        diagnostics.concat(formatter_diagnostics) if formatter_diagnostics
         diagnostics
       end
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,9 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/requests/support/rubocop_formatting_runner"
-require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
-
 module RubyLsp
   module Requests
     # ![Formatting symbol demo](../../formatting.gif)
@@ -26,47 +23,24 @@ module RubyLsp
     # end
     # ```
     class Formatting < Request
-      class Error < StandardError; end
-      class InvalidFormatter < StandardError; end
-
-      @formatters = T.let({}, T::Hash[String, Support::FormatterRunner])
-
-      class << self
-        extend T::Sig
-
-        sig { returns(T::Hash[String, Support::FormatterRunner]) }
-        attr_reader :formatters
-
-        sig { params(identifier: String, instance: Support::FormatterRunner).void }
-        def register_formatter(identifier, instance)
-          @formatters[identifier] = instance
-        end
-      end
-
-      if defined?(Support::RuboCopFormattingRunner)
-        register_formatter("rubocop", Support::RuboCopFormattingRunner.instance)
-      end
-
-      if defined?(Support::SyntaxTreeFormattingRunner)
-        register_formatter("syntax_tree", Support::SyntaxTreeFormattingRunner.instance)
-      end
-
       extend T::Sig
 
-      sig { params(document: Document, formatter: String).void }
-      def initialize(document, formatter: "auto")
+      class Error < StandardError; end
+
+      sig { params(global_state: GlobalState, document: Document).void }
+      def initialize(global_state, document)
         super()
         @document = document
+        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
         @uri = T.let(document.uri, URI::Generic)
-        @formatter = formatter
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def perform
-        return if @formatter == "none"
+        return unless @active_formatter
         return if @document.syntax_error?
 
-        formatted_text = formatted_file
+        formatted_text = @active_formatter.run_formatting(@uri, @document)
         return unless formatted_text
 
         size = @document.source.size
@@ -82,16 +56,6 @@ module RubyLsp
           ),
         ]
       end
-
-      private
-
-      sig { returns(T.nilable(String)) }
-      def formatted_file
-        formatter_runner = Formatting.formatters[@formatter]
-        raise InvalidFormatter, "Formatter is not available: #{@formatter}" unless formatter_runner
-
-        formatter_runner.run(@uri, @document)
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/hover.rb

@@ -64,7 +64,7 @@ module RubyLsp
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
         Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)
         Addon.addons.each do |addon|
-          addon.create_hover_listener(@response_builder, global_state, nesting, dispatcher)
+          addon.create_hover_listener(@response_builder, nesting, dispatcher)
         end
 
         @dispatcher = dispatcher

data/lib/ruby_lsp/requests/request.rb

@@ -8,6 +8,8 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
+      class InvalidFormatter < StandardError; end
+
       abstract!
 
       sig { abstract.returns(T.anything) }

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -29,7 +29,7 @@ module RubyLsp
         sig { returns(Interface::SemanticTokensRegistrationOptions) }
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
-            document_selector: { scheme: "file", language: "ruby" },
+            document_selector: [{ language: "ruby" }],
             legend: Interface::SemanticTokensLegend.new(
               token_types: ResponseBuilders::SemanticHighlighting::TOKEN_TYPES.keys,
               token_modifiers: ResponseBuilders::SemanticHighlighting::TOKEN_MODIFIERS.keys,

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

@@ -0,0 +1,26 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module Formatter
+        extend T::Sig
+        extend T::Helpers
+
+        interface!
+
+        sig { abstract.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        def run_formatting(uri, document); end
+
+        sig do
+          abstract.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+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
+          @diagnostic_runner = T.let(RuboCopRunner.new, RuboCopRunner)
+          # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
+          @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
+        end
+
+        sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
+        def run_formatting(uri, document)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
+
+          # Invoke RuboCop with just this file in `paths`
+          @format_runner.run(filename, document.source)
+          @format_runner.formatted_source
+        end
+
+        sig do
+          override.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document)
+          filename = T.must(uri.to_standardized_path || uri.opaque)
+          # Invoke RuboCop with just this file in `paths`
+          @diagnostic_runner.run(filename, document.source)
+
+          @diagnostic_runner.offenses.map do |offense|
+            Support::RuboCopDiagnostic.new(document, offense, uri).to_lsp_diagnostic
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/support/{syntax_tree_formatting_runner.rb → syntax_tree_formatter.rb}

@@ -14,10 +14,10 @@ module RubyLsp
   module Requests
     module Support
       # :nodoc:
-      class SyntaxTreeFormattingRunner
+      class SyntaxTreeFormatter
         extend T::Sig
         include Singleton
-        include Support::FormatterRunner
+        include Support::Formatter
 
         sig { void }
         def initialize
@@ -33,12 +33,22 @@ module RubyLsp
         end
 
         sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
-        def run(uri, document)
+        def run_formatting(uri, document)
           path = uri.to_standardized_path
           return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
 
           SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
+
+        sig do
+          override.params(
+            uri: URI::Generic,
+            document: Document,
+          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        end
+        def run_diagnostic(uri, document)
+          nil
+        end
       end
     end
   end

data/lib/ruby_lsp/requests.rb

@@ -56,7 +56,7 @@ module RubyLsp
       autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :Common, "ruby_lsp/requests/support/common"
-      autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
+      autoload :Formatter, "ruby_lsp/requests/support/formatter"
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -88,6 +88,26 @@ module RubyLsp
       $stderr.puts("Error processing #{message[:method]}: #{e.full_message}")
     end
 
+    sig { void }
+    def load_addons
+      Addon.load_addons(@global_state, @outgoing_queue)
+      errored_addons = Addon.addons.select(&:error?)
+
+      if errored_addons.any?
+        send_message(
+          Notification.new(
+            method: "window/showMessage",
+            params: Interface::ShowMessageParams.new(
+              type: Constant::MessageType::WARNING,
+              message: "Error loading addons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
+            ),
+          ),
+        )
+
+        $stderr.puts(errored_addons.map(&:backtraces).join("\n\n"))
+      end
+    end
+
     private
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -213,23 +233,7 @@ module RubyLsp
 
     sig { void }
     def run_initialized
-      Addon.load_addons(@outgoing_queue)
-      errored_addons = Addon.addons.select(&:error?)
-
-      if errored_addons.any?
-        send_message(
-          Notification.new(
-            method: "window/showMessage",
-            params: Interface::ShowMessageParams.new(
-              type: Constant::MessageType::WARNING,
-              message: "Error loading addons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
-            ),
-          ),
-        )
-
-        $stderr.puts(errored_addons.map(&:backtraces).join("\n\n"))
-      end
-
+      load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
       indexing_config = {}
@@ -254,6 +258,13 @@ module RubyLsp
         end
       end
 
+      if defined?(Requests::Support::RuboCopFormatter)
+        @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.instance)
+      end
+      if defined?(Requests::Support::SyntaxTreeFormatter)
+        @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.instance)
+      end
+
       perform_initial_indexing(indexing_config)
       check_formatter_is_available
     end
@@ -387,9 +398,9 @@ module RubyLsp
         return
       end
 
-      response = Requests::Formatting.new(@store.get(uri), formatter: @global_state.formatter).perform
+      response = Requests::Formatting.new(@global_state, @store.get(uri)).perform
       send_message(Result.new(id: message[:id], response: response))
-    rescue Requests::Formatting::InvalidFormatter => error
+    rescue Requests::Request::InvalidFormatter => error
       send_message(Notification.window_show_error("Configuration error: #{error.message}"))
       send_empty_response(message[:id])
     rescue StandardError, LoadError => error
@@ -512,7 +523,7 @@ module RubyLsp
       end
 
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
-        Requests::Diagnostics.new(document).perform
+        Requests::Diagnostics.new(@global_state, document).perform
       end
 
       send_message(
@@ -521,6 +532,9 @@ module RubyLsp
           response: response && Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response),
         ),
       )
+    rescue Requests::Request::InvalidFormatter => error
+      send_message(Notification.window_show_error("Configuration error: #{error.message}"))
+      send_empty_response(message[:id])
     rescue StandardError, LoadError => error
       send_message(Notification.window_show_error("Error running diagnostics: #{error.message}"))
       send_empty_response(message[:id])

data/lib/ruby_lsp/test_helper.rb

@@ -13,10 +13,12 @@ module RubyLsp
           source: T.nilable(String),
           uri: URI::Generic,
           stub_no_typechecker: T::Boolean,
+          load_addons: T::Boolean,
           block: T.proc.params(server: RubyLsp::Server, uri: URI::Generic).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end
-    def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, &block)
+    def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
+      &block)
       server = RubyLsp::Server.new(test_mode: true)
       server.global_state.stubs(:typechecker).returns(false) if stub_no_typechecker
 
@@ -37,8 +39,13 @@ module RubyLsp
         RubyIndexer::IndexablePath.new(nil, T.must(uri.to_standardized_path)),
         source,
       )
+      server.load_addons if load_addons
       block.call(server, uri)
     ensure
+      if load_addons
+        RubyLsp::Addon.addons.each(&:deactivate)
+        RubyLsp::Addon.addons.clear
+      end
       T.must(server).run_shutdown
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-27 00:00:00.000000000 Z
+date: 2024-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -134,15 +134,14 @@ files:
 - lib/ruby_lsp/requests/signature_help.rb
 - lib/ruby_lsp/requests/support/annotation.rb
 - lib/ruby_lsp/requests/support/common.rb
-- lib/ruby_lsp/requests/support/formatter_runner.rb
+- lib/ruby_lsp/requests/support/formatter.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
-- lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
-- lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
+- lib/ruby_lsp/requests/support/rubocop_formatter.rb
 - lib/ruby_lsp/requests/support/rubocop_runner.rb
 - lib/ruby_lsp/requests/support/selection_range.rb
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
-- lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb
+- lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
 - lib/ruby_lsp/response_builders.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb

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

@@ -1,18 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    module Support
-      module FormatterRunner
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        sig { abstract.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
-        def run(uri, document); end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
-
-require "singleton"
-
-module RubyLsp
-  module Requests
-    module Support
-      # :nodoc:
-      class RuboCopDiagnosticsRunner
-        extend T::Sig
-        include Singleton
-
-        sig { void }
-        def initialize
-          @runner = T.let(RuboCopRunner.new, RuboCopRunner)
-        end
-
-        sig { params(uri: URI::Generic, document: Document).returns(T::Array[Support::RuboCopDiagnostic]) }
-        def run(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
-          # Invoke RuboCop with just this file in `paths`
-          @runner.run(filename, document.source)
-
-          @runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(document, offense, uri)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
-
-require "singleton"
-
-module RubyLsp
-  module Requests
-    module Support
-      # :nodoc:
-      class RuboCopFormattingRunner
-        extend T::Sig
-        include Singleton
-        include Support::FormatterRunner
-
-        sig { void }
-        def initialize
-          # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
-          @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
-        end
-
-        sig { override.params(uri: URI::Generic, document: Document).returns(String) }
-        def run(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
-
-          # Invoke RuboCop with just this file in `paths`
-          @runner.run(filename, document.source)
-
-          @runner.formatted_source
-        end
-      end
-    end
-  end
-end