Handle multiple formatters

Default.sublime-commands

@@ -57,6 +57,11 @@
         "caption": "LSP: Format File",
         "command": "lsp_format_document",
     },
+    {
+        "caption": "LSP: Format File With…",
+        "command": "lsp_format_document",
+        "args": {"select": true}
+    },
     {
         "caption": "LSP: Format Selection",
         "command": "lsp_format_document_range",

plugin/core/windows.py

@@ -80,6 +80,8 @@ def __init__(self, window: sublime.Window, workspace: ProjectFolders, config_man
         self._server_log = []  # type: List[Tuple[str, str]]
         self.panel_manager = PanelManager(self._window)  # type: Optional[PanelManager]
         self.tree_view_sheets = {}  # type: Dict[str, TreeViewSheet]
+        self.formatters = {}  # type: Dict[str, str]
+        self.formatter_updated_in_project = False
         self.total_error_count = 0
         self.total_warning_count = 0
         sublime.set_timeout(functools.partial(self._update_panel_main_thread, _NO_DIAGNOSTICS_PLACEHOLDER, []))
@@ -106,6 +108,9 @@ def on_load_project_async(self) -> None:
         self._config_manager.update()
 
     def on_post_save_project_async(self) -> None:
+        if self.formatter_updated_in_project:
+            self.formatter_updated_in_project = False
+            return
         self.on_load_project_async()
 
     def update_workspace_folders_async(self) -> None:

plugin/formatting.py

@@ -4,6 +4,7 @@
 from .core.protocol import TextDocumentSaveReason
 from .core.protocol import TextEdit
 from .core.registry import LspTextCommand
+from .core.registry import windows
 from .core.sessions import Session
 from .core.settings import userprefs
 from .core.typing import Any, Callable, List, Optional, Iterator, Union
@@ -15,6 +16,7 @@
 from .core.views import text_document_ranges_formatting
 from .core.views import will_save_wait_until
 from .save_command import LspSaveCommand, SaveTask
+from functools import partial
 import sublime
 
 
@@ -100,16 +102,70 @@ class LspFormatDocumentCommand(LspTextCommand):
 
     capability = 'documentFormattingProvider'
 
-    def is_enabled(self, event: Optional[dict] = None, point: Optional[int] = None) -> bool:
+    def is_enabled(self, event: Optional[dict] = None, select: bool = False) -> bool:
+        if select:
+            return len(list(self.sessions(self.capability))) > 1
         return super().is_enabled() or bool(self.best_session(LspFormatDocumentRangeCommand.capability))
 
-    def run(self, edit: sublime.Edit, event: Optional[dict] = None) -> None:
-        format_document(self).then(self.on_result)
+    def run(self, edit: sublime.Edit, event: Optional[dict] = None, select: bool = False) -> None:
+        session_names = [session.config.name for session in self.sessions(self.capability)]
+        base_scope = self.view.scope_name(0).split()[0]
+        if select:
+            self.select_formatter(base_scope, session_names)
+        elif len(session_names) > 1:
+            window = self.view.window()
+            if not window:
+                return
+            formatter = None
+            project_data = window.project_data()
+            if isinstance(project_data, dict):
+                formatter = project_data.get('settings', {}).get('LSP', {}).get('formatters', {}).get(base_scope)
+            else:
+                window_manager = windows.lookup(window)
+                if window_manager:
+                    formatter = window_manager.formatters.get(base_scope)
+            if formatter:
+                session = self.session_by_name(formatter, self.capability)
+                if session:
+                    session.send_request_task(text_document_formatting(self.view)).then(self.on_result)
+            else:
+                self.select_formatter(base_scope, session_names)
+        else:
+            format_document(self).then(self.on_result)
 
     def on_result(self, result: FormatResponse) -> None:
         if result and not isinstance(result, Error):
             apply_text_edits_to_view(result, self.view)
 
+    def select_formatter(self, base_scope: str, session_names: List[str]) -> None:
+        window = self.view.window()
+        if not window:
+            return
+        window.show_quick_panel(
+            session_names, partial(self.on_select_formatter, base_scope, session_names), placeholder="Select Formatter")
+
+    def on_select_formatter(self, base_scope: str, session_names: List[str], index: int) -> None:
+        if index > -1:
+            session_name = session_names[index]
+            window = self.view.window()
+            if window:
+                window_manager = windows.lookup(window)
+                if window_manager:
+                    project_data = window.project_data()
+                    if isinstance(project_data, dict):
+                        project_settings = project_data.setdefault('settings', dict())
+                        project_lsp_settings = project_settings.setdefault('LSP', dict())
+                        project_formatter_settings = project_lsp_settings.setdefault('formatters', dict())
+                        project_formatter_settings[base_scope] = session_name
+                        # Prevent restart of all sessions after project file save
+                        window_manager.formatter_updated_in_project = True
+                        window.set_project_data(project_data)
+                    else:  # Save temporarily for this window
+                        window_manager.formatters[base_scope] = session_name
+            session = self.session_by_name(session_name, self.capability)
+            if session:
+                session.send_request_task(text_document_formatting(self.view)).then(self.on_result)
+
 
 class LspFormatDocumentRangeCommand(LspTextCommand):
 

sublime-package.json

@@ -780,6 +780,14 @@
                 "LSP": {
                   "type": "object",
                   "markdownDescription": "The dictionary of your configured language servers or overrides for existing configurations. The keys of this dictionary are free-form. They give a humany-friendly name to the server configuration. They are shown in the bottom-left corner in the status bar once attached to a view (unless you have `\"show_view_status\"` set to `false`).",
+                  "properties": {
+                    "formatters": {
+                      "type": "object",
+                      "additionalProperties": {
+                        "type": "string"
+                      }
+                    }
+                  },
                   "additionalProperties": {
                     "$ref": "sublime://settings/LSP#/definitions/ClientConfig"
                   }