Add selector API in AbstractPlugin (#2620)

Author: rchl

plugin/core/configurations.py

@@ -21,8 +21,8 @@
 class WindowConfigChangeListener(metaclass=ABCMeta):
 
     @abstractmethod
-    def on_configs_changed(self, config_name: str | None = None) -> None:
-        raise NotImplementedError()
+    def on_configs_changed(self, configs: list[ClientConfig]) -> None:
+        raise NotImplementedError
 
 
 class WindowConfigManager:
@@ -54,7 +54,7 @@ def match_view(self, view: sublime.View, include_disabled: bool = False) -> Gene
                 return
             scheme = parse_uri(uri)[0]
             for config in self.all.values():
-                if config.match_view(view, scheme) and (config.enabled or include_disabled):
+                if (config.enabled or include_disabled) and config.match_view(view, scheme):
                     yield config
         except (IndexError, RuntimeError):
             pass
@@ -65,6 +65,7 @@ def update(self, updated_config_name: str | None = None) -> None:
     def _reload_configs(self, updated_config_name: str | None = None, notify_listeners: bool = False) -> None:
         project_data = self._window.project_data()
         project_settings = project_data.get("settings", {}).get("LSP", {}) if isinstance(project_data, dict) else {}
+        updated_configs: list[ClientConfig] = []
         if updated_config_name is None:
             self.all.clear()
         for name, config in self._global_configs.items():
@@ -77,18 +78,22 @@ def _reload_configs(self, updated_config_name: str | None = None, notify_listene
                 overrides = {}
             if name in self._disabled_for_session:
                 overrides["enabled"] = False
-            self.all[name] = ClientConfig.from_config(config, overrides)
+            updated_config = ClientConfig.from_config(config, overrides)
+            self.all[name] = updated_config
+            updated_configs.append(updated_config)
         for name, c in project_settings.items():
             if updated_config_name and updated_config_name != name:
                 continue
             debug("loading project-only configuration", name)
             try:
-                self.all[name] = ClientConfig.from_dict(name, c)
+                updated_config = ClientConfig.from_dict(name, c)
+                self.all[name] = updated_config
+                updated_configs.append(updated_config)
             except Exception as ex:
                 exception_log(f"failed to load project-only configuration {name}", ex)
         if notify_listeners:
             for listener in self._change_listeners:
-                listener.on_configs_changed(updated_config_name)
+                listener.on_configs_changed(updated_configs)
 
     def enable_config(self, config_name: str) -> None:
         if not self._reenable_disabled_for_session(config_name):

plugin/core/registry.py

@@ -227,9 +227,7 @@ def restart_server(self, wm: WindowManager, index: int) -> None:
             return
 
         def run_async() -> None:
-            config_name = self._config_names[index]
-            if config_name:
-                wm.restart_sessions_async(config_name)
+            wm.restart_sessions_async([self._config_names[index]])
 
         sublime.set_timeout_async(run_async)
 

plugin/core/sessions.py

@@ -862,6 +862,16 @@ def configuration(cls) -> tuple[sublime.Settings, str]:
         filepath = f"Packages/LSP-{name}/{basename}"
         return sublime.load_settings(basename), filepath
 
+    @classmethod
+    def selector(cls, view: sublime.View, config: ClientConfig) -> str:
+        """
+        Override the default selector used to determine whether server should run on the given view.
+
+        :param      view:             The view
+        :param      config:           The config
+        """
+        return config.selector
+
     @classmethod
     def additional_variables(cls) -> dict[str, str] | None:
         """

plugin/core/types.py

@@ -849,10 +849,12 @@ def erase_view_status(self, view: sublime.View) -> None:
         view.erase_status(self.status_key)
 
     def match_view(self, view: sublime.View, scheme: str) -> bool:
+        from .sessions import get_plugin
         syntax = view.syntax()
         if not syntax:
             return False
-        selector = self.selector.strip()
+        plugin = get_plugin(self.name)
+        selector = plugin.selector(view, self).strip() if plugin else self.selector.strip()
         if not selector:
             return False
         return scheme in self.schemes and sublime.score_selector(syntax.scope, selector) > 0

plugin/core/windows.py

@@ -163,7 +163,8 @@ def _dequeue_listener_async(self) -> None:
                 listener = self._pending_listeners.pop()
                 if not listener.view.is_valid():
                     # debug("listener", listener, "is no longer valid")
-                    return self._dequeue_listener_async()
+                    self._dequeue_listener_async()
+                    return
                 # debug("adding new pending listener", listener)
                 self._listeners.add(listener)
             except IndexError:
@@ -269,7 +270,8 @@ def start_async(self, config: ClientConfig, initiating_view: sublime.View) -> No
                     # Continue with handling pending listeners
                     self._new_session = None
                     sublime.set_timeout_async(self._dequeue_listener_async)
-                    return self._window.status_message(message)
+                    self._window.status_message(message)
+                    return
                 cwd = plugin_class.on_pre_start(self._window, initiating_view, workspace_folders, config)
             config.set_view_status(initiating_view, "starting...")
             session = Session(self, self._create_logger(config.name), workspace_folders, config, plugin_class)
@@ -341,17 +343,17 @@ def handle_message_request(self, session: Session, params: Any, request_id: Any)
         if view:
             MessageRequestHandler(view, session, request_id, params, session.config.name).show()
 
-    def restart_sessions_async(self, config_name: str | None = None) -> None:
-        self._end_sessions_async(config_name)
+    def restart_sessions_async(self, config_names: list[str]) -> None:
+        self._end_sessions_async(config_names)
         listeners = list(self._listeners)
         self._listeners.clear()
         for listener in listeners:
             self.register_listener_async(listener)
 
-    def _end_sessions_async(self, config_name: str | None = None) -> None:
+    def _end_sessions_async(self, config_names: list[str] | None = None) -> None:
         sessions = list(self._sessions)
         for session in sessions:
-            if config_name is None or config_name == session.config.name:
+            if config_names is None or session.config.name in config_names:
                 session.end_async()
                 self._sessions.discard(session)
 
@@ -515,8 +517,9 @@ def _update_panel_main_thread(self, characters: str, prephantoms: list[tuple[int
 
     # --- Implements WindowConfigChangeListener ------------------------------------------------------------------------
 
-    def on_configs_changed(self, config_name: str | None = None) -> None:
-        sublime.set_timeout_async(lambda: self.restart_sessions_async(config_name))
+    def on_configs_changed(self, configs: list[ClientConfig]) -> None:
+        config_names = [config.name for config in configs]
+        sublime.set_timeout_async(lambda: self.restart_sessions_async(config_names))
 
 
 class WindowRegistry(LspSettingsChangeListener):