Merge pull request #743 from oraios/intelephense-ignore-vendor-setting

Intelephense: Add configurable setting `ignore_vendor`

src/solidlsp/language_servers/csharp_language_server.py

@@ -247,17 +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()
-        ls_specific_settings = solidlsp_settings.ls_specific_settings or {}
-        language_specific_config = ls_specific_settings.get(language_enum, {})
+        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 +441,8 @@ class CSharpLanguageServer(SolidLanguageServer):
         logger.log("Downloading .NET 9 runtime...", logging.INFO)
         dotnet_dir.mkdir(parents=True, exist_ok=True)
 
-        custom_dotnet_runtime_url = solidlsp_settings.ls_specific_settings.get(cls.get_language_enum_instance(), {}).get(
-            "dotnet_runtime_url"
-        )
+        custom_settings = solidlsp_settings.get_ls_specific_settings(cls.get_language_enum_instance())
+        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._solidlsp_settings.ls_specific_settings.get(self.get_language_enum_instance(), {})
 
         # 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/language_servers/intelephense.py

@@ -26,17 +26,14 @@ class Intelephense(SolidLanguageServer):
     Provides PHP specific instantiation of the LanguageServer class using Intelephense.
 
     You can pass the following entries in ls_specific_settings["php"]:
-        - maxMemory
-        - maxFileSize
+        - maxMemory: sets intelephense.maxMemory
+        - maxFileSize: sets intelephense.files.maxSize
+        - ignore_vendor: whether or ignore directories named "vendor" (default: true)
     """
 
     @override
     def is_ignored_dirname(self, dirname: str) -> bool:
-        # For PHP projects, we should ignore:
-        # - vendor: third-party dependencies <managed by Composer
-        # - node_modules: if the project has JavaScript components
-        # - cache: commonly used for caching
-        return super().is_ignored_dirname(dirname) or dirname in ["node_modules", "vendor", "cache"]
+        return super().is_ignored_dirname(dirname) or dirname in self._ignored_dirnames
 
     @classmethod
     def _setup_runtime_dependencies(cls, logger: LanguageServerLogger, solidlsp_settings: SolidLSPSettings) -> list[str]:
@@ -100,6 +97,18 @@ class Intelephense(SolidLanguageServer):
         )
         self.request_id = 0
 
+        # For PHP projects, we should ignore:
+        # - node_modules: if the project has JavaScript components
+        # - cache: commonly used for caching
+        # - (configurable) vendor: third-party dependencies <managed by Composer
+        self._ignored_dirnames = {"node_modules", "cache"}
+        if self._custom_settings.get("ignore_vendor", True):
+            self._ignored_dirnames.add("vendor")
+        self.logger.log(
+            f"Ignoring the following directories for PHP projects: {', '.join(sorted(self._ignored_dirnames))}",
+            logging.INFO,
+        )
+
     def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialization params for the Intelephense Language Server.
@@ -130,9 +139,8 @@ class Intelephense(SolidLanguageServer):
         if license_key:
             initialization_options["licenceKey"] = license_key
 
-        custom_intelephense_settings = self._solidlsp_settings.ls_specific_settings.get(self.get_language_enum_instance(), {})
-        max_memory = custom_intelephense_settings.get("maxMemory")
-        max_file_size = custom_intelephense_settings.get("maxFileSize")
+        max_memory = self._custom_settings.get("maxMemory")
+        max_file_size = self._custom_settings.get("maxFileSize")
         if max_memory is not None:
             initialization_options["intelephense.maxMemory"] = max_memory
         if max_file_size is not None:

src/solidlsp/ls.py

@@ -176,6 +176,12 @@ class SolidLanguageServer(ABC):
                     as opposed to HTTP, TCP modes supported by some language servers.
         """
         self._solidlsp_settings = solidlsp_settings
+        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:
@@ -23,7 +28,7 @@ class SolidLSPSettings:
     For instance, if this is ".solidlsp" and the project is located at "/home/user/myproject",
     then Solid-LSP will store project-specific data in "/home/user/myproject/.solidlsp".
     """
-    ls_specific_settings: dict["Language", Any] = field(default_factory=dict)
+    ls_specific_settings: dict["Language", dict[str, Any]] = field(default_factory=dict)
     """
     Advanced configuration option allowing to configure language server implementation specific options.
     Have a look at the docstring of the constructors of the corresponding LS implementations within solidlsp to see which options are available.
@@ -37,3 +42,32 @@ class SolidLSPSettings:
     @property
     def ls_resources_dir(self):
         return os.path.join(str(self.solidlsp_dir), "language_servers", "static")
+
+    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.CustomLSSettings(self.ls_specific_settings.get(language))