java-functional-lsp 0.9.2__tar.gz → 0.9.4__tar.gz

{java_functional_lsp-0.9.2 → java_functional_lsp-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.2
+Version: 0.9.4
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp

{java_functional_lsp-0.9.2 → java_functional_lsp-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.2"
+version = "0.9.4"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.9.2 → java_functional_lsp-0.9.4}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.9.2"
+__version__ = "0.9.4"

{java_functional_lsp-0.9.2 → java_functional_lsp-0.9.4}/src/java_functional_lsp/proxy.py

@@ -448,12 +448,12 @@ def _version_key(name: str) -> tuple[int, ...]:
 def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
     """Return the tightest Maven multi-module parent of *initial_module*.
 
-    Walks up from ``initial_module.parent`` (the module itself is skipped —
-    we want its *parent* group, not the module's own pom) toward (and
-    including) ``workspace_root``, returning the first ancestor whose
-    ``pom.xml`` contains a ``<modules>`` section.  Falls back to
-    ``workspace_root`` when no such intermediate parent exists (e.g. flat
-    single-level monorepos).
+    Walks up from ``initial_module.parent`` toward (but NOT including)
+    ``workspace_root``, returning the first ancestor whose ``pom.xml``
+    contains a ``<modules>`` section.  Falls back to ``initial_module``
+    itself when no intermediate group pom exists (e.g. modules that sit
+    directly under ``workspace_root``), keeping the scope as tight as
+    possible and avoiding accidental full-monorepo indexing.
 
     This keeps the jdtls index bounded to a module *group* (typically
     5-20 modules) rather than the full IDE workspace (potentially 200+ modules)
@@ -463,11 +463,17 @@ def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
     before walking to avoid symlink-based boundary escapes.
     """
     workspace_root = workspace_root.resolve()
-    current = initial_module.resolve().parent
-    # Bail immediately if the initial module is outside the workspace.
+    resolved_module = initial_module.resolve()
+    current = resolved_module.parent
+    # Case 1: module is outside the workspace entirely — scope to workspace_root
+    # (also fires when initial_module == workspace_root, since parent is then
+    # outside workspace_root).
     if not current.is_relative_to(workspace_root):
         return workspace_root
-    while True:
+    # Walk up to (but NOT including) workspace_root.  Inspecting workspace_root's
+    # own pom.xml would include the entire monorepo (e.g. 200+ modules) → OOM.
+    # `current.parent == current` detects the filesystem root (POSIX `/` or Windows drive).
+    while current not in (workspace_root, current.parent):
         pom = current / "pom.xml"
         if pom.is_file():
             try:
@@ -475,10 +481,10 @@ def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
                     return current
             except OSError:
                 pass
-        if current in (workspace_root, current.parent):
-            break
         current = current.parent
-    return workspace_root
+    # Case 2: no intermediate group pom found — use the initial module as its own scope
+    # (tightest possible; avoids full-monorepo indexing for flat modules under workspace_root).
+    return resolved_module
 
 
 @lru_cache(maxsize=256)
@@ -530,6 +536,22 @@ def _compute_module_diff(
     return (diff, current)
 
 
+def _wipe_data_dir(data_dir: Path) -> None:
+    """Remove *data_dir* so the next jdtls startup gets a clean cold start.
+
+    Called after an initialize timeout to recover from a corrupted OSGi
+    data-dir (e.g. left behind after an OOM crash).
+    """
+    shutil.rmtree(data_dir, ignore_errors=True)
+    if data_dir.exists():
+        logger.warning(
+            "jdtls: failed to wipe data-dir %s — next retry may hang again",
+            _redact_path(str(data_dir)),
+        )
+    else:
+        logger.info("jdtls: wiped data-dir %s after init timeout", _redact_path(str(data_dir)))
+
+
 def _clear_cache_on_version_change(cache_root: Path) -> None:
     """Clear jdtls data cache when the server version changes.
 
@@ -747,6 +769,7 @@ class JdtlsProxy:
             if result is None:
                 logger.error("jdtls initialize request failed or timed out")
                 await self.stop()
+                await asyncio.get_running_loop().run_in_executor(None, _wipe_data_dir, data_dir)
                 return False
 
             self._jdtls_capabilities = result.get("capabilities", {})
@@ -907,8 +930,10 @@ class JdtlsProxy:
         Maven parent.  This covers sibling modules (the common case for
         cross-module navigation) without ballooning the index.
 
-        Falls back to the full IDE workspace root when no intermediate
-        multi-module parent is found.
+        Falls back to the initial module itself when no intermediate
+        multi-module parent is found (e.g. flat modules sitting directly
+        under the workspace root), keeping the jdtls scope as tight as
+        possible.
 
         Removes all individually-added module folders to avoid double-indexing
         with the newly added group root.

{java_functional_lsp-0.9.2 → java_functional_lsp-0.9.4}/tests/test_proxy.py

@@ -851,6 +851,7 @@ class TestStartPassesEnvToSubprocess:
             patch.object(JdtlsProxy, "_stderr_reader", side_effect=fake_stderr_reader),
             patch.object(JdtlsProxy, "send_request", side_effect=fake_send_request),
             patch.object(JdtlsProxy, "stop", side_effect=lambda: None),
+            patch.object(proxy_mod, "_wipe_data_dir"),  # avoid blocking rmtree in tests
         ):
             ok = await proxy.start({"rootUri": f"file://{tmp_path}"})
 
@@ -859,6 +860,67 @@ class TestStartPassesEnvToSubprocess:
         # The crucial assertion: env= was passed through to the subprocess call.
         assert captured["env"] == sentinel_env
 
+    @pytest.mark.asyncio
+    async def test_wipe_runs_in_executor_on_init_timeout(self, tmp_path: Any) -> None:
+        """_wipe_data_dir must be dispatched via run_in_executor to avoid blocking the event loop."""
+        from unittest.mock import patch
+
+        import java_functional_lsp.proxy as proxy_mod
+
+        proxy = JdtlsProxy()
+        proxy._jdtls_on_path = True
+
+        fake_process = MagicMock()
+        fake_process.pid = 99999
+        fake_process.stdout = MagicMock()
+        fake_process.stderr = MagicMock()
+        fake_process.returncode = 0
+
+        async def fake_wait() -> int:
+            return 0
+
+        fake_process.wait = fake_wait
+
+        async def fake_create_subprocess(*_a: Any, **_kw: Any) -> Any:
+            return fake_process
+
+        async def fake_reader_loop(_: Any) -> None:
+            return None
+
+        async def fake_stderr_reader(_: Any) -> None:
+            return None
+
+        async def fake_send_request(*_a: Any, **_kw: Any) -> None:
+            return None  # simulate initialize timeout
+
+        wipe_calls: list[Any] = []
+
+        async def fake_run_in_executor(_executor: Any, fn: Any, *args: Any) -> Any:
+            if fn is proxy_mod._wipe_data_dir:
+                wipe_calls.append((fn, args))
+                return None
+            # Other blocking calls (e.g. _blocking_startup) must run for real
+            return fn(*args)
+
+        fake_loop = MagicMock()
+        fake_loop.run_in_executor = fake_run_in_executor
+
+        with (
+            patch.object(proxy_mod.shutil, "which", return_value="/fake/jdtls"),
+            patch.object(proxy_mod, "build_jdtls_env", return_value={}),
+            patch.object(proxy_mod.asyncio, "create_subprocess_exec", side_effect=fake_create_subprocess),
+            patch.object(JdtlsProxy, "_reader_loop", side_effect=fake_reader_loop),
+            patch.object(JdtlsProxy, "_stderr_reader", side_effect=fake_stderr_reader),
+            patch.object(JdtlsProxy, "send_request", side_effect=fake_send_request),
+            patch.object(JdtlsProxy, "stop", side_effect=lambda: None),
+            patch("java_functional_lsp.proxy.asyncio.get_running_loop", return_value=fake_loop),
+        ):
+            ok = await proxy.start({"rootUri": f"file://{tmp_path}"})
+
+        assert ok is False
+        assert len(wipe_calls) == 1
+        assert wipe_calls[0][0] is proxy_mod._wipe_data_dir
+
 
 class TestFindModuleRoot:
     """Tests for find_module_root — build-file detection for module scoping."""
@@ -1069,17 +1131,24 @@ class TestLazyStart:
         assert event["added"][0]["uri"] == group.as_uri()
         assert event["added"][0]["uri"] != workspace_uri
 
-    async def test_expand_falls_back_to_workspace_root_when_no_group_pom(self, tmp_path: Path) -> None:
-        """Falls back to the IDE workspace root when no intermediate multi-module parent exists."""
+    async def test_expand_noop_for_flat_module_directly_under_workspace(self, tmp_path: Path) -> None:
+        """No notification sent for flat modules sitting directly under workspace_root.
+
+        When there is no intermediate group pom between the module and workspace_root,
+        _find_maven_group_root returns the module itself (not workspace_root). Since the
+        module was already added, expand_full_workspace() is a no-op — which is correct:
+        the scope is already as tight as possible and workspace_root's pom.xml
+        (potentially 200+ modules → OOM) is never inspected.
+        """
         from unittest.mock import AsyncMock
 
         from java_functional_lsp.proxy import JdtlsProxy
 
-        # Flat layout: workspace/module — no intermediate pom.xml
+        # Flat layout: workspace/module — no intermediate pom.xml between module and workspace
         workspace = tmp_path / "workspace"
         module = workspace / "module"
         module.mkdir(parents=True)
-        # workspace/pom.xml has <modules>, but there's nothing in between
+        # workspace/pom.xml has <modules>, but the walk stops BEFORE reaching it
         (workspace / "pom.xml").write_text("<project><modules><module>module</module></modules></project>")
 
         module_uri = module.as_uri()
@@ -1093,9 +1162,9 @@ class TestLazyStart:
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
 
-        call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
-        event = call_args[1]["event"]
-        assert event["added"][0]["uri"] == workspace_uri
+        # No notification — module was already added and is already the tightest scope
+        proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
+        assert proxy._workspace_expanded is True
 
     async def test_expand_full_workspace_sends_notification(self) -> None:
         from unittest.mock import AsyncMock
@@ -1110,28 +1179,43 @@ class TestLazyStart:
         proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
         assert proxy._workspace_expanded is True
 
-    async def test_expand_full_workspace_removes_initial_module(self) -> None:
-        """All modules in _states (not just _initial_module_uri) are removed on expansion."""
+    async def test_expand_full_workspace_removes_initial_module(self, tmp_path: Path) -> None:
+        """All modules in _states are removed when expanding to an intermediate group root."""
         from unittest.mock import AsyncMock
 
         from java_functional_lsp.proxy import JdtlsProxy
 
+        # Layout: monorepo/group/module-a, monorepo/group/module-b
+        # group/pom.xml has <modules> → group becomes the expansion target
+        monorepo = tmp_path / "monorepo"
+        group = monorepo / "group"
+        module_a = group / "module-a"
+        module_b = group / "module-b"
+        for d in (module_a, module_b):
+            d.mkdir(parents=True)
+        (group / "pom.xml").write_text("<project><modules><module>module-a</module></modules></project>")
+
+        module_a_uri = module_a.as_uri()
+        module_b_uri = module_b.as_uri()
+        monorepo_uri = monorepo.as_uri()
+        group_uri = group.as_uri()
+
         proxy = JdtlsProxy()
         proxy._available = True
-        proxy._original_root_uri = "file:///workspace/monorepo"
-        proxy._initial_module_uri = "file:///workspace/monorepo/module-a"
-        # Simulate that module-a was mark_added during start() and module-b via add_module_if_new
-        proxy.modules.mark_added("file:///workspace/monorepo/module-a")
-        proxy.modules.mark_added("file:///workspace/monorepo/module-b")
+        proxy._original_root_uri = monorepo_uri
+        proxy._initial_module_uri = module_a_uri
+        # Simulate module-a added during start() and module-b via add_module_if_new
+        proxy.modules.mark_added(module_a_uri)
+        proxy.modules.mark_added(module_b_uri)
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
         call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
         event = call_args[1]["event"]
         removed_uris = {e["uri"] for e in event["removed"]}
-        assert "file:///workspace/monorepo/module-a" in removed_uris
-        assert "file:///workspace/monorepo/module-b" in removed_uris
-        assert event["added"][0]["uri"] == "file:///workspace/monorepo"
+        assert module_a_uri in removed_uris
+        assert module_b_uri in removed_uris
+        assert event["added"][0]["uri"] == group_uri
 
     async def test_expand_full_workspace_noop_when_not_available(self) -> None:
         from unittest.mock import AsyncMock
@@ -1167,7 +1251,8 @@ class TestLazyStart:
         proxy._jdtls_on_path = True
         captured: dict[str, Any] = {}
 
-        async def capturing_start(params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
+        async def capturing_start(_params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
+            _ = config
             captured["module_root_uri"] = module_root_uri
             return False
 
@@ -1191,7 +1276,8 @@ class TestLazyStart:
 
         captured: dict[str, Any] = {}
 
-        async def capturing_start(params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
+        async def capturing_start(_params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
+            _ = config
             captured["module_root_uri"] = module_root_uri
             return False
 
@@ -1215,3 +1301,58 @@ class TestLazyStart:
         module_root = "file:///workspace/monorepo/module-a"
         module_hash = hashlib.sha256(module_root.encode()).hexdigest()[:12]
         assert expected_hash != module_hash
+
+
+# ---------------------------------------------------------------------------
+# _wipe_data_dir
+# ---------------------------------------------------------------------------
+
+
+class TestWipeDataDir:
+    def test_wipe_removes_directory(self, tmp_path: Path) -> None:
+        """Directory is removed and info is logged."""
+        from java_functional_lsp.proxy import _wipe_data_dir
+
+        data_dir = tmp_path / "data"
+        data_dir.mkdir()
+        (data_dir / "some_file.dat").write_text("x")
+
+        _wipe_data_dir(data_dir)
+
+        assert not data_dir.exists()
+
+    def test_wipe_logs_warning_when_removal_fails(self, tmp_path: Path) -> None:
+        """Warning is logged when rmtree silently fails (dir still present)."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import _wipe_data_dir
+
+        data_dir = tmp_path / "data"
+        data_dir.mkdir()
+
+        with patch("shutil.rmtree"):  # no-op — dir remains
+            with patch("java_functional_lsp.proxy.logger") as mock_logger:
+                _wipe_data_dir(data_dir)
+                mock_logger.warning.assert_called_once()
+                # info must NOT be called when wipe failed
+                mock_logger.info.assert_not_called()
+
+    def test_wipe_logs_info_on_success(self, tmp_path: Path) -> None:
+        """Info is logged (not warning) when directory is successfully removed."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import _wipe_data_dir
+
+        data_dir = tmp_path / "data"
+        data_dir.mkdir()
+
+        with patch("java_functional_lsp.proxy.logger") as mock_logger:
+            _wipe_data_dir(data_dir)
+            mock_logger.info.assert_called_once()
+            mock_logger.warning.assert_not_called()
+
+    def test_wipe_nonexistent_dir_does_not_raise(self, tmp_path: Path) -> None:
+        """Calling wipe on a non-existent dir is safe."""
+        from java_functional_lsp.proxy import _wipe_data_dir
+
+        _wipe_data_dir(tmp_path / "ghost")  # should not raise