Refactor retrieval of LS-specific settings, adding abstraction

and ensuring that all relevant retrievals are logged

src/solidlsp/language_servers/csharp_language_server.py

@@ -247,16 +247,10 @@ class CSharpLanguageServer(SolidLanguageServer):
         Ensure .NET runtime and Microsoft.CodeAnalysis.LanguageServer are available.
         Returns a tuple of (dotnet_path, language_server_dll_path).
         """
-        language_enum = cls.get_language_enum_instance()
         language_specific_config = solidlsp_settings.get_ls_specific_settings(cls.get_language_enum_instance())
         runtime_dependency_overrides = cast(list[dict[str, Any]], language_specific_config.get("runtime_dependencies", []))
 
         logger.log("Resolving runtime dependencies", logging.DEBUG)
-        if language_specific_config:
-            logger.log(
-                f"Language-specific config for {language_enum}: {language_specific_config}",
-                logging.DEBUG,
-            )
 
         runtime_dependencies = RuntimeDependencyCollection(
             _RUNTIME_DEPENDENCIES,
@@ -448,9 +442,7 @@ class CSharpLanguageServer(SolidLanguageServer):
         dotnet_dir.mkdir(parents=True, exist_ok=True)
 
         custom_settings = solidlsp_settings.get_ls_specific_settings(cls.get_language_enum_instance())
-        custom_dotnet_runtime_url = custom_settings.get(
-            "dotnet_runtime_url"
-        )
+        custom_dotnet_runtime_url = custom_settings.get("dotnet_runtime_url")
         if custom_dotnet_runtime_url is not None:
             logger.log(f"Using custom .NET runtime url: {custom_dotnet_runtime_url}", logging.INFO)
             url = custom_dotnet_runtime_url

src/solidlsp/language_servers/eclipse_jdtls.py

@@ -343,52 +343,51 @@ class EclipseJDTLS(SolidLanguageServer):
         repo_uri = pathlib.Path(repository_absolute_path).as_uri()
 
         # Load user's Maven and Gradle configuration paths from ls_specific_settings["java"]
-        custom_java_settings = self._custom_settings
 
         # Maven settings: default to ~/.m2/settings.xml
-        default_maven_settings = os.path.join(os.path.expanduser("~"), ".m2", "settings.xml")
-        maven_user_settings = None
-        if "maven_user_settings" in custom_java_settings:
+        default_maven_settings_path = os.path.join(os.path.expanduser("~"), ".m2", "settings.xml")
+        custom_maven_settings_path = self._custom_settings.get("maven_user_settings")
+        if custom_maven_settings_path is not None:
             # User explicitly provided a path
-            maven_settings_path = custom_java_settings["maven_user_settings"]
-            if not os.path.exists(maven_settings_path):
+            if not os.path.exists(custom_maven_settings_path):
                 error_msg = (
-                    f"Maven settings file not found: {maven_settings_path}. "
+                    f"Provided maven settings file not found: {custom_maven_settings_path}. "
                     f"Fix: create the file, update path in ~/.serena/serena_config.yml (ls_specific_settings -> java -> maven_user_settings), "
-                    f"or remove the setting to use default (~/.m2/settings.xml)"
+                    f"or remove the setting to use default ({default_maven_settings_path})"
                 )
                 self.logger.log(error_msg, logging.ERROR)
                 raise FileNotFoundError(error_msg)
-            maven_user_settings = maven_settings_path
-            self.logger.log(f"Using Maven settings from custom location: {maven_user_settings}", logging.INFO)
-        elif os.path.exists(default_maven_settings):
-            maven_user_settings = default_maven_settings
-            self.logger.log(f"Using Maven settings from default location: {maven_user_settings}", logging.INFO)
+            maven_settings_path = custom_maven_settings_path
+            self.logger.log(f"Using Maven settings from custom location: {maven_settings_path}", logging.INFO)
+        elif os.path.exists(default_maven_settings_path):
+            maven_settings_path = default_maven_settings_path
+            self.logger.log(f"Using Maven settings from default location: {maven_settings_path}", logging.INFO)
         else:
+            maven_settings_path = None
             self.logger.log(
-                f"Maven settings not found at default location ({default_maven_settings}), will use JDTLS defaults", logging.INFO
+                f"Maven settings not found at default location ({default_maven_settings_path}), will use JDTLS defaults", logging.INFO
             )
 
         # Gradle user home: default to ~/.gradle
         default_gradle_home = os.path.join(os.path.expanduser("~"), ".gradle")
-        gradle_user_home = None
-        if "gradle_user_home" in custom_java_settings:
+        custom_gradle_home = self._custom_settings.get("gradle_user_home")
+        if custom_gradle_home is not None:
             # User explicitly provided a path
-            gradle_user_home_path = custom_java_settings["gradle_user_home"]
-            if not os.path.exists(gradle_user_home_path):
+            if not os.path.exists(custom_gradle_home):
                 error_msg = (
-                    f"Gradle user home directory not found: {gradle_user_home_path}. "
+                    f"Gradle user home directory not found: {custom_gradle_home}. "
                     f"Fix: create the directory, update path in ~/.serena/serena_config.yml (ls_specific_settings -> java -> gradle_user_home), "
                     f"or remove the setting to use default (~/.gradle)"
                 )
                 self.logger.log(error_msg, logging.ERROR)
                 raise FileNotFoundError(error_msg)
-            gradle_user_home = gradle_user_home_path
+            gradle_user_home = custom_gradle_home
             self.logger.log(f"Using Gradle user home from custom location: {gradle_user_home}", logging.INFO)
         elif os.path.exists(default_gradle_home):
             gradle_user_home = default_gradle_home
             self.logger.log(f"Using Gradle user home from default location: {gradle_user_home}", logging.INFO)
         else:
+            gradle_user_home = None
             self.logger.log(
                 f"Gradle user home not found at default location ({default_gradle_home}), will use JDTLS defaults", logging.INFO
             )
@@ -579,7 +578,7 @@ class EclipseJDTLS(SolidLanguageServer):
                             "checkProjectSettingsExclusions": False,
                             "updateBuildConfiguration": "interactive",
                             "maven": {
-                                "userSettings": maven_user_settings,
+                                "userSettings": maven_settings_path,
                                 "globalSettings": None,
                                 "notCoveredPluginExecutionSeverity": "warning",
                                 "defaultMojoExecutionAction": "ignore",

src/solidlsp/ls.py

@@ -176,7 +176,12 @@ class SolidLanguageServer(ABC):
                     as opposed to HTTP, TCP modes supported by some language servers.
         """
         self._solidlsp_settings = solidlsp_settings
-        self._custom_settings = solidlsp_settings.get_ls_specific_settings(self.get_language_enum_instance())
+        lang = self.get_language_enum_instance()
+        self._custom_settings = solidlsp_settings.get_ls_specific_settings(lang)
+        logger.log(
+            f"Custom config (LS-specific settings) for {lang}: {self._custom_settings}",
+            logging.DEBUG,
+        )
         self._encoding = config.encoding
         self.logger = logger
         self.repository_root_path: str = repository_root_path

src/solidlsp/settings.py

@@ -2,14 +2,19 @@
 Defines settings for Solid-LSP
 """
 
+import logging
 import os
 import pathlib
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from sensai.util.string import ToStringMixin
+
 if TYPE_CHECKING:
     from solidlsp.ls_config import Language
 
+log = logging.getLogger(__name__)
+
 
 @dataclass
 class SolidLSPSettings:
@@ -38,11 +43,31 @@ class SolidLSPSettings:
     def ls_resources_dir(self):
         return os.path.join(str(self.solidlsp_dir), "language_servers", "static")
 
-    def get_ls_specific_settings(self, language: "Language") -> dict[str, Any]:
+    class CustomLSSettings(ToStringMixin):
+        def __init__(self, settings: dict[str, Any] | None) -> None:
+            self.settings = settings or {}
+
+        def get(self, key: str, default_value: Any = None) -> Any:
+            """
+            Returns the custom setting for the given key or the default value if not set.
+            If a custom value is set for the given key, the retrieval is logged.
+
+            :param key: the key
+            :param default_value: the default value to use if no custom value is set
+            :return: the value
+            """
+            if key in self.settings:
+                value = self.settings[key]
+                log.info("Using custom LS setting %s for key '%s'", value, key)
+            else:
+                value = default_value
+            return value
+
+    def get_ls_specific_settings(self, language: "Language") -> CustomLSSettings:
         """
         Get the language server specific settings for the given language.
 
         :param language: The programming language.
         :return: A dictionary of settings for the language server.
         """
-        return self.ls_specific_settings.get(language, {})
+        return self.CustomLSSettings(self.ls_specific_settings.get(language))