From 18855ed9de868c3b693311f3422cf5729cdd3981 Mon Sep 17 00:00:00 2001 From: Eduardo Villalpando Mello Date: Tue, 17 Nov 2026 11:01:50 -0800 Subject: [PATCH] refactor: extract private workspace and document routing Delegate settings routing to stateless private helpers while retaining live ToolServer state, public normalization seams, and distinct lookup fallbacks. Add focused facade regressions and document the private boundary. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Copilot-Session: 85ef72cc-9e26-4bc4-b1c3-55256d9bef91 --- CONTRIBUTING.md | 8 +- python/tests/test_server.py | 81 ++++++++++++ python/vscode_common_python_lsp/_routing.py | 134 ++++++++++++++++++++ python/vscode_common_python_lsp/server.py | 87 ++----------- 4 files changed, 230 insertions(+), 80 deletions(-) create mode 100644 python/vscode_common_python_lsp/_routing.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 1248fe0..0b6096b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -33,9 +33,11 @@ installation, VS Code host or Node build. Repeated settings application is covered separately in-process, not by reinitializing a live LSP session. `ToolServer` remains the public settings facade and owns the writable global and -workspace dictionaries, in-place updates, path normalization and routing. -Private `_settings` helpers only construct fresh, shallow settings dictionaries -from the current values; they retain nested value aliases and cache no state. +workspace dictionaries. Private `_settings` helpers construct fresh, shallow +settings dictionaries while retaining nested value aliases. Private `_routing` +helpers consult the facade on each call for in-place updates and workspace/document +selection, preserving path normalization and the distinct lookup fallbacks. +Neither private module caches settings or owns persistent state. ## Adoption and milestones diff --git a/python/tests/test_server.py b/python/tests/test_server.py index 266e584..af63a4d 100644 --- a/python/tests/test_server.py +++ b/python/tests/test_server.py @@ -224,6 +224,14 @@ def test_workspace_without_filesystem_path_is_skipped(self, mock_uris): assert settings["workspace"] == "file:///local-workspace" assert settings["workspaceFS"] + def test_only_virtual_workspaces_do_not_add_a_cwd_fallback(self): + ts = _make_server() + workspaces = ts.workspace_settings + ts.update_workspace_settings([{"workspace": "pico:"}]) + + assert ts.workspace_settings is workspaces + assert workspaces == {} + class TestGetSettingsByPath: def test_matches_closest_workspace(self): @@ -961,6 +969,79 @@ def test_get_cwd_different_drives_no_crash(self): class TestSettingsContract: + def test_routing_uses_replaced_and_mutated_settings_maps(self, tmp_path): + ts = _make_server() + root = tmp_path / "workspace" + project = root / "project" + document = TextDocument((project / "demo.py").as_uri()) + file_path = pathlib.Path(document.path) + ts.update_workspace_settings([{"workspace": root.as_uri()}]) + original = next(iter(ts.workspace_settings.values())) + assert ts.get_settings_by_document(document) is original + assert ts.get_settings_by_path(file_path) is original + + root_key = str(pathlib.Path(uris.to_fs_path(root.as_uri()))) + project_key = str(pathlib.Path(uris.to_fs_path(project.as_uri()))) + root_settings = {"workspaceFS": root_key} + project_settings = {"workspaceFS": project_key} + workspaces = {root_key: root_settings, project_key: project_settings} + globals_ = {"args": ["--replacement"]} + ts.workspace_settings = workspaces + ts.global_settings = globals_ + + assert ts.get_document_key(document) == project_key + assert ts.get_settings_by_document(document) is project_settings + assert ts.get_settings_by_path(file_path) is project_settings + + del workspaces[project_key] + assert ts.get_document_key(document) == root_key + assert ts.get_settings_by_document(document) is root_settings + assert ts.get_settings_by_path(file_path) is root_settings + + workspaces.clear() + assert ts.get_document_key(document) is None + assert ts.get_settings_by_path(file_path)["args"] is globals_["args"] + globals_["args"] = ["--mutated"] + assert ts.get_settings_by_document(document)["args"] is globals_["args"] + assert ts.workspace_settings is workspaces + assert workspaces == {} + + def test_document_routing_preserves_facade_method_overrides(self, tmp_path): + ts = _make_server() + document = TextDocument((tmp_path / "demo.py").as_uri()) + settings = {"custom": True} + ts.workspace_settings = {"custom-key": settings} + ts.get_document_key = MagicMock(return_value="custom-key") + + assert ts.get_settings_by_document(document) is settings + ts.get_document_key.assert_called_once_with(document) + + args = ["--custom-default"] + ts.get_global_defaults = MagicMock(return_value={"args": args}) + ts.get_document_key.return_value = None + fallback = ts.get_settings_by_document(document) + assert fallback["args"] is args + ts.get_global_defaults.assert_called_once_with() + assert ts.workspace_settings == {"custom-key": settings} + + @pytest.mark.parametrize("relative", [False, True], ids=["anchor", "rootless"]) + def test_routing_does_not_match_the_terminal_parent(self, tmp_path, relative): + ts = _make_server() + terminal = pathlib.Path(".") if relative else pathlib.Path(tmp_path.anchor) + file_path = terminal / "src" / "demo.py" + document = _make_document(str(file_path)) + first = {"workspaceFS": "first-workspace"} + ts.workspace_settings = { + "first-workspace": first, + str(terminal): {"workspaceFS": str(terminal)}, + } + + assert ts.get_document_key(document) is None + assert ts.get_settings_by_path(file_path) is first + fallback = ts.get_settings_by_document(document) + assert fallback["workspaceFS"] == str(file_path.parent) + assert fallback is not first + def test_shared_producer_payload_and_staged_cwd(self, tmp_path): root = tmp_path / "workspace café" root.mkdir() diff --git a/python/vscode_common_python_lsp/_routing.py b/python/vscode_common_python_lsp/_routing.py new file mode 100644 index 0000000..2a4665a --- /dev/null +++ b/python/vscode_common_python_lsp/_routing.py @@ -0,0 +1,134 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +"""Private, stateless workspace/document routing for the ToolServer facade.""" + +from __future__ import annotations + +import os +import pathlib +from collections.abc import Callable +from types import ModuleType +from typing import TYPE_CHECKING, Any + +from pygls.workspace import TextDocument + +from . import _settings + +if TYPE_CHECKING: + from .server import ToolServer + + +def update_workspace_settings( + facade: ToolServer, + settings: list[dict[str, Any]] | None, + *, + normalize_path: Callable[..., str], + uris: ModuleType, +) -> None: + """Populate the facade's current workspace dictionary in place.""" + if not settings: + key = normalize_path( + os.getcwd(), resolve_symlinks=facade.config.resolve_symlinks + ) + facade.workspace_settings[key] = _settings.get_fallback_settings( + key, uris.from_fs_path(key), facade.get_global_defaults() + ) + return + + for setting in settings: + workspace_path = uris.to_fs_path(setting["workspace"]) + # Virtual workspace roots, such as "pico:", have no local + # filesystem path, so they cannot be registered here. + if workspace_path is None: + continue + + key = normalize_path( + workspace_path, + resolve_symlinks=facade.config.resolve_symlinks, + ) + facade.workspace_settings[key] = _settings.get_workspace_settings( + key, facade.get_global_defaults(), setting + ) + + +def get_settings_by_path( + facade: ToolServer, + file_path: pathlib.Path, + *, + normalize_path: Callable[..., str], + uris: ModuleType, +) -> dict[str, Any]: + """Select workspace settings, falling back to CWD or the first workspace.""" + if not facade.workspace_settings: + cwd = normalize_path( + os.getcwd(), resolve_symlinks=facade.config.resolve_symlinks + ) + return _settings.get_fallback_settings( + cwd, uris.from_fs_path(cwd), facade.get_global_defaults() + ) + + workspaces = {s["workspaceFS"] for s in facade.workspace_settings.values()} + + while file_path != file_path.parent: + str_file_path = normalize_path( + str(file_path), resolve_symlinks=facade.config.resolve_symlinks + ) + if str_file_path in workspaces: + return facade.workspace_settings[str_file_path] + file_path = file_path.parent + + return list(facade.workspace_settings.values())[0] + + +def get_document_key( + facade: ToolServer, + document: TextDocument, + *, + normalize_path: Callable[..., str], +) -> str | None: + """Find the nearest workspace key without a first-workspace fallback.""" + if facade.workspace_settings: + document_workspace = pathlib.Path(document.path) + workspaces = {s["workspaceFS"] for s in facade.workspace_settings.values()} + + while document_workspace != document_workspace.parent: + norm_path = normalize_path( + str(document_workspace), + resolve_symlinks=facade.config.resolve_symlinks, + ) + if norm_path in workspaces: + return norm_path + document_workspace = document_workspace.parent + + return None + + +def get_settings_by_document( + facade: ToolServer, + document: TextDocument | None, + *, + normalize_path: Callable[..., str], + uris: ModuleType, +) -> dict[str, Any]: + """Select settings, retaining the distinct absent/outside-document fallbacks.""" + if document is None or document.path is None: + if not facade.workspace_settings: + cwd = normalize_path( + os.getcwd(), resolve_symlinks=facade.config.resolve_symlinks + ) + return _settings.get_fallback_settings( + cwd, uris.from_fs_path(cwd), facade.get_global_defaults() + ) + return list(facade.workspace_settings.values())[0] + + key = facade.get_document_key(document) + if key is not None: + return facade.workspace_settings[key] + + key = normalize_path( + str(pathlib.Path(document.path).parent), + resolve_symlinks=facade.config.resolve_symlinks, + ) + return _settings.get_fallback_settings( + key, uris.from_fs_path(key), facade.get_global_defaults() + ) diff --git a/python/vscode_common_python_lsp/server.py b/python/vscode_common_python_lsp/server.py index 47294ae..b4685f3 100644 --- a/python/vscode_common_python_lsp/server.py +++ b/python/vscode_common_python_lsp/server.py @@ -19,7 +19,7 @@ from pygls.lsp.server import LanguageServer from pygls.workspace import TextDocument -from . import _settings, jsonrpc +from . import _routing, _settings, jsonrpc from .context import substitute_attr from .paths import normalize_path from .runner import RunResult, run_module, run_path @@ -122,91 +122,24 @@ def get_global_defaults(self) -> dict[str, Any]: def update_workspace_settings(self, settings: list[dict[str, Any]] | None) -> None: """Populate :attr:`workspace_settings` from the client payload.""" - if not settings: - key = normalize_path( - os.getcwd(), resolve_symlinks=self.config.resolve_symlinks - ) - self.workspace_settings[key] = _settings.get_fallback_settings( - key, uris.from_fs_path(key), self.get_global_defaults() - ) - return - - for setting in settings: - workspace_path = uris.to_fs_path(setting["workspace"]) - # Virtual workspace roots, such as "pico:", have no local - # filesystem path, so they cannot be registered here. - if workspace_path is None: - continue - - key = normalize_path( - workspace_path, - resolve_symlinks=self.config.resolve_symlinks, - ) - self.workspace_settings[key] = _settings.get_workspace_settings( - key, self.get_global_defaults(), setting - ) + _routing.update_workspace_settings( + self, settings, normalize_path=normalize_path, uris=uris + ) def get_settings_by_path(self, file_path: pathlib.Path) -> dict[str, Any]: """Return workspace settings for the given file path.""" - if not self.workspace_settings: - cwd = normalize_path( - os.getcwd(), resolve_symlinks=self.config.resolve_symlinks - ) - return _settings.get_fallback_settings( - cwd, uris.from_fs_path(cwd), self.get_global_defaults() - ) - - workspaces = {s["workspaceFS"] for s in self.workspace_settings.values()} - - while file_path != file_path.parent: - str_file_path = normalize_path( - str(file_path), resolve_symlinks=self.config.resolve_symlinks - ) - if str_file_path in workspaces: - return self.workspace_settings[str_file_path] - file_path = file_path.parent - - return list(self.workspace_settings.values())[0] + return _routing.get_settings_by_path( + self, file_path, normalize_path=normalize_path, uris=uris + ) def get_document_key(self, document: TextDocument) -> str | None: """Return the workspace key for the given document, or ``None``.""" - if self.workspace_settings: - document_workspace = pathlib.Path(document.path) - workspaces = {s["workspaceFS"] for s in self.workspace_settings.values()} - - while document_workspace != document_workspace.parent: - norm_path = normalize_path( - str(document_workspace), - resolve_symlinks=self.config.resolve_symlinks, - ) - if norm_path in workspaces: - return norm_path - document_workspace = document_workspace.parent - - return None + return _routing.get_document_key(self, document, normalize_path=normalize_path) def get_settings_by_document(self, document: TextDocument | None) -> dict[str, Any]: """Return workspace settings for the given document.""" - if document is None or document.path is None: - if not self.workspace_settings: - cwd = normalize_path( - os.getcwd(), resolve_symlinks=self.config.resolve_symlinks - ) - return _settings.get_fallback_settings( - cwd, uris.from_fs_path(cwd), self.get_global_defaults() - ) - return list(self.workspace_settings.values())[0] - - key = self.get_document_key(document) - if key is not None: - return self.workspace_settings[key] - - key = normalize_path( - str(pathlib.Path(document.path).parent), - resolve_symlinks=self.config.resolve_symlinks, - ) - return _settings.get_fallback_settings( - key, uris.from_fs_path(key), self.get_global_defaults() + return _routing.get_settings_by_document( + self, document, normalize_path=normalize_path, uris=uris ) # -----------------------------------------------------------------