Allow extensions to register formatters

Author: vinistock

lib/ruby_lsp/executor.rb

@@ -543,6 +543,8 @@ def check_formatter_is_available
       return unless @store.formatter == "rubocop"
 
       unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
+        @store.formatter = "none"
+
         @message_queue << Notification.new(
           message: "window/showMessage",
           params: Interface::ShowMessageParams.new(

lib/ruby_lsp/requests.rb

@@ -49,6 +49,7 @@ module Support
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
       autoload :Common, "ruby_lsp/requests/support/common"
+      autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"
     end
   end
 end

lib/ruby_lsp/requests/formatting.rb

@@ -29,6 +29,29 @@ class Formatting < BaseRequest
       class Error < StandardError; end
       class InvalidFormatter < StandardError; end
 
+      @formatters = T.let(
+        {
+          "syntax_tree" => Support::SyntaxTreeFormattingRunner.instance,
+        },
+        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
+
       extend T::Sig
 
       sig { params(document: Document, formatter: String).void }
@@ -41,6 +64,8 @@ def initialize(document, formatter: "auto")
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
+        return if @formatter == "none"
+
         # Don't try to format files outside the current working directory
         return unless @uri.sub("file://", "").start_with?(Dir.pwd)
 
@@ -67,16 +92,10 @@ def run
 
       sig { returns(T.nilable(String)) }
       def formatted_file
-        case @formatter
-        when "rubocop"
-          if defined?(Support::RuboCopFormattingRunner)
-            Support::RuboCopFormattingRunner.instance.run(@uri, @document)
-          end
-        when "syntax_tree"
-          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
-        else
-          raise InvalidFormatter, "Unknown formatter: #{@formatter}"
-        end
+        formatter_runner = Formatting.formatters[@formatter]
+        raise InvalidFormatter, "Formatter is not available: #{@formatter}" unless formatter_runner
+
+        formatter_runner.run(@uri, @document)
       end
     end
   end

lib/ruby_lsp/requests/support/formatter_runner.rb

@@ -0,0 +1,18 @@
+# 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: String, document: Document).returns(T.nilable(String)) }
+        def run(uri, document); end
+      end
+    end
+  end
+end

lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb

@@ -13,14 +13,15 @@ module Support
       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 { params(uri: String, document: Document).returns(String) }
+        sig { override.params(uri: String, document: Document).returns(String) }
         def run(uri, document)
           filename = CGI.unescape(URI.parse(uri).path)
 

lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb

@@ -11,6 +11,7 @@ module Support
       class SyntaxTreeFormattingRunner
         extend T::Sig
         include Singleton
+        include Support::FormatterRunner
 
         sig { void }
         def initialize
@@ -25,7 +26,7 @@ def initialize
             )
         end
 
-        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { override.params(uri: String, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
           relative_path = Pathname.new(URI(uri).path).relative_path_from(T.must(WORKSPACE_URI.path))
           return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }

test/executor_test.rb

@@ -181,7 +181,7 @@ def test_shows_error_if_formatter_set_to_rubocop_but_rubocop_not_available
       executor.execute(method: "initialize", params: { initializationOptions: { formatter: "rubocop" } })
       executor.execute(method: "initialized")
 
-      assert_equal("rubocop", @store.formatter)
+      assert_equal("none", @store.formatter)
       refute_empty(@message_queue)
       notification = T.must(@message_queue.pop)
       assert_equal("window/showMessage", notification.message)

test/requests/formatting_test.rb

@@ -137,6 +137,25 @@ def test_raises_on_invalid_formatter
     end
   end
 
+  def test_using_a_custom_formatter
+    require "singleton"
+    formatter_class = Class.new do
+      include Singleton
+      include RubyLsp::Requests::Support::FormatterRunner
+
+      def run(uri, document)
+        "#{document.source}\n# formatter by my-custom-formatter"
+      end
+    end
+
+    RubyLsp::Requests::Formatting.register_formatter("my-custom-formatter", T.unsafe(formatter_class).instance)
+    assert_includes(formatted_document("my-custom-formatter"), "# formatter by my-custom-formatter")
+  end
+
+  def test_returns_nil_when_formatter_is_none
+    assert_nil(formatted_document("none"))
+  end
+
   private
 
   def formatted_document(formatter)
@@ -159,5 +178,9 @@ def clear_syntax_tree_runner_singleton_instance
     return unless defined?(RubyLsp::Requests::Support::SyntaxTreeFormattingRunner)
 
     T.unsafe(Singleton).__init__(RubyLsp::Requests::Support::SyntaxTreeFormattingRunner)
+    RubyLsp::Requests::Formatting.register_formatter(
+      "syntax_tree",
+      RubyLsp::Requests::Support::SyntaxTreeFormattingRunner.instance,
+    )
   end
 end