feat: add ConfigurationMap for flexible LSP configuration management

Author: observerw

src/lsp_client/capability/server_request/configuration.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from abc import abstractmethod
 from collections.abc import Iterator
 from typing import Any, Protocol, override, runtime_checkable
 
@@ -13,6 +12,7 @@
     ServerRequestHookRegistry,
     WorkspaceCapabilityProtocol,
 )
+from lsp_client.utils.config import ConfigurationMap
 from lsp_client.utils.types import lsp_type
 
 
@@ -27,6 +27,8 @@ class WithRespondConfigurationRequest(
     `workspace/configuration` - https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workspace_configuration
     """
 
+    configuration_map: ConfigurationMap | None = None
+
     @override
     @classmethod
     def iter_methods(cls) -> Iterator[str]:
@@ -46,17 +48,15 @@ def register_workspace_capability(
     def check_server_capability(cls, cap: lsp_type.ServerCapabilities) -> None:
         super().check_server_capability(cap)
 
-    @abstractmethod
     def get_configuration(self, scope_uri: str | None, section: str | None) -> Any:
         """
         Get the configuration value for the given scope URI and section.
 
-        If a client supports this capability, it's the user's responsibility to implement this method to return the appropriate configuration value.
-
-        :param scope_uri: The scope URI for which to get the configuration.
-        :param section: The section of the configuration to get.
-        :return: The configuration value.
+        Default implementation uses `self.configuration_map` if available.
         """
+        if self.configuration_map:
+            return self.configuration_map.get(scope_uri, section)
+        return None
 
     async def _respond_configuration(
         self, params: lsp_type.ConfigurationParams

src/lsp_client/utils/config.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import fnmatch
+from copy import deepcopy
+from typing import Any
+
+from attrs import define, field
+from loguru import logger
+
+from lsp_client.utils.uri import from_local_uri
+
+
+def deep_merge(base: dict[str, Any], update: dict[str, Any]) -> dict[str, Any]:
+    """
+    Recursively merge two dictionaries.
+    """
+    result = deepcopy(base)
+    for key, value in update.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = deep_merge(result[key], value)
+        else:
+            result[key] = deepcopy(value)
+    return result
+
+
+@define
+class ConfigurationMap:
+    """
+    A helper class to manage LSP configuration.
+    Supports global configuration and scope-specific overrides.
+    """
+
+    _global_config: dict[str, Any] = field(factory=dict)
+    _scoped_configs: list[tuple[str, dict[str, Any]]] = field(factory=list)
+
+    def add_scope(self, pattern: str, config: dict[str, Any]) -> None:
+        """
+        Add a configuration override for a specific file pattern.
+
+        :param pattern: Glob pattern (e.g. "**/tests/**", "*.py")
+        :param config: The configuration dict to merge for this scope
+        """
+        self._scoped_configs.append((pattern, config))
+
+    def _get_section(self, config: Any, section: str | None) -> Any:
+        if not section:
+            return config
+
+        # Traverse the config dictionary using the section path (e.g. "python.analysis")
+        current = config
+        for part in section.split("."):
+            if isinstance(current, dict) and part in current:
+                current = current[part]
+            else:
+                return None
+        return current
+
+    def get(self, scope_uri: str | None, section: str | None) -> Any:
+        # Start with global config
+        final_config = self._global_config
+
+        # If we have a scope, merge matching scoped configs
+        if scope_uri:
+            try:
+                path_str = str(from_local_uri(scope_uri))
+                for pattern, scoped_config in self._scoped_configs:
+                    if fnmatch.fnmatch(path_str, pattern):
+                        final_config = deep_merge(final_config, scoped_config)
+            except Exception:
+                logger.warning(f"Failed to parse scope URI: {scope_uri}")
+
+        return self._get_section(final_config, section)