""" Provides YAML specific instantiation of the LanguageServer class using yaml-language-server. Contains various configurations and settings specific to YAML files. """ import logging import os import shutil from typing import Any from solidlsp.language_servers.common import RuntimeDependency, RuntimeDependencyCollection, build_npm_install_command from solidlsp.ls import LanguageServerDependencyProvider, LanguageServerDependencyProviderSinglePath, SolidLanguageServer from solidlsp.ls_config import LanguageServerConfig from solidlsp.settings import SolidLSPSettings log = logging.getLogger(__name__) # Version pinning convention (see eclipse_jdtls.py for the full spec): # INITIAL_* — frozen forever; legacy unversioned install dir is reserved for it. # DEFAULT_* — bumped on upgrades; goes into a versioned subdir. INITIAL_YAML_LANGUAGE_SERVER_VERSION = "1.19.2" DEFAULT_YAML_LANGUAGE_SERVER_VERSION = "1.19.2" class YamlLanguageServer(SolidLanguageServer): """ Provides YAML specific instantiation of the LanguageServer class using yaml-language-server. Contains various configurations and settings specific to YAML files. """ @staticmethod def _determine_log_level(line: str) -> int: """Classify yaml-language-server stderr output to avoid false-positive errors.""" line_lower = line.lower() # Known informational messages from yaml-language-server that aren't critical errors if any( [ "cannot find module" in line_lower and "package.json" in line_lower, # Schema resolution - not critical "no parser" in line_lower, # Parser messages - informational ] ): return logging.DEBUG return SolidLanguageServer._determine_log_level(line) def __init__(self, config: LanguageServerConfig, repository_root_path: str, solidlsp_settings: SolidLSPSettings): """ Creates a YamlLanguageServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead. """ super().__init__( config, repository_root_path, None, "yaml", solidlsp_settings, ) def _create_dependency_provider(self) -> LanguageServerDependencyProvider: return self.DependencyProvider(self._custom_settings, self._ls_resources_dir) class DependencyProvider(LanguageServerDependencyProviderSinglePath): def _get_or_install_core_dependency(self) -> str: """ Setup runtime dependencies for YAML Language Server and return the command to start the server. """ # Verify both node and npm are installed is_node_installed = shutil.which("node") is not None assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again." is_npm_installed = shutil.which("npm") is not None assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again." yaml_language_server_version = self._custom_settings.get("yaml_language_server_version", DEFAULT_YAML_LANGUAGE_SERVER_VERSION) npm_registry = self._custom_settings.get("npm_registry") deps = RuntimeDependencyCollection( [ RuntimeDependency( id="yaml-language-server", description="yaml-language-server package (Red Hat)", command=build_npm_install_command("yaml-language-server", yaml_language_server_version, npm_registry), platform_id="any", ), ] ) # legacy unversioned dir reserved for INITIAL; every other version goes into a versioned subdir ls_dirname = ( "yaml-lsp" if yaml_language_server_version == INITIAL_YAML_LANGUAGE_SERVER_VERSION else f"yaml-lsp-{yaml_language_server_version}" ) yaml_ls_dir = os.path.join(self._ls_resources_dir, ls_dirname) yaml_executable_path = os.path.join(yaml_ls_dir, "node_modules", ".bin", "yaml-language-server") # Handle Windows executable extension if os.name == "nt": yaml_executable_path += ".cmd" if not os.path.exists(yaml_executable_path): log.info(f"YAML Language Server executable not found at {yaml_executable_path}. Installing...") deps.install(yaml_ls_dir) log.info("YAML language server dependencies installed successfully") if not os.path.exists(yaml_executable_path): raise FileNotFoundError( f"yaml-language-server executable not found at {yaml_executable_path}, something went wrong with the installation." ) return yaml_executable_path def _create_launch_command(self, core_path: str) -> list[str]: return [core_path, "--stdio"] def _create_base_initialize_params(self) -> dict: """ Returns the initialize params for the YAML Language Server. """ initialize_params = { "locale": "en", "capabilities": { "textDocument": { "synchronization": {"didSave": True, "dynamicRegistration": True}, "completion": {"dynamicRegistration": True, "completionItem": {"snippetSupport": True}}, "definition": {"dynamicRegistration": True}, "references": {"dynamicRegistration": True}, "documentSymbol": { "dynamicRegistration": True, "hierarchicalDocumentSymbolSupport": True, "symbolKind": {"valueSet": list(range(1, 27))}, }, "hover": {"dynamicRegistration": True, "contentFormat": ["markdown", "plaintext"]}, "codeAction": {"dynamicRegistration": True}, }, "workspace": { "workspaceFolders": True, "didChangeConfiguration": {"dynamicRegistration": True}, "symbol": {"dynamicRegistration": True}, }, }, "initializationOptions": { "yaml": { "schemaStore": {"enable": True, "url": "https://www.schemastore.org/api/json/catalog.json"}, "format": {"enable": True}, "validate": True, "hover": True, "completion": True, } }, } return initialize_params def _start_server(self) -> None: """ Starts the YAML Language Server, waits for the server to be ready and yields the LanguageServer instance. """ def register_capability_handler(params: Any) -> None: return def do_nothing(params: Any) -> None: return def window_log_message(msg: dict) -> None: log.info(f"LSP: window/logMessage: {msg}") self.server.on_request("client/registerCapability", register_capability_handler) self.server.on_notification("window/logMessage", window_log_message) self.server.on_notification("$/progress", do_nothing) self.server.on_notification("textDocument/publishDiagnostics", do_nothing) log.info("Starting YAML server process") self.server.start() initialize_params = self._create_initialize_params() log.info("Sending initialize request from LSP client to LSP server and awaiting response") init_response = self.server.send.initialize(initialize_params) log.debug(f"Received initialize response from YAML server: {init_response}") # Verify document symbol support is available if "documentSymbolProvider" in init_response["capabilities"]: log.info("YAML server supports document symbols") else: log.warning("Warning: YAML server does not report document symbol support") self.server.notify.initialized({}) # YAML language server is ready immediately after initialization log.info("YAML server initialization complete")