java-functional-lsp 0.9.1__tar.gz → 0.9.3__tar.gz

{java_functional_lsp-0.9.1 → java_functional_lsp-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.1
+Version: 0.9.3
 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.1 → java_functional_lsp-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.1"
+version = "0.9.3"
 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.1 → java_functional_lsp-0.9.3}/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.1"
+__version__ = "0.9.3"

{java_functional_lsp-0.9.1 → java_functional_lsp-0.9.3}/src/java_functional_lsp/proxy.py

@@ -445,6 +445,42 @@ def _version_key(name: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
+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).
+
+    This keeps the jdtls index bounded to a module *group* (typically
+    5-20 modules) rather than the full IDE workspace (potentially 200+ modules)
+    which would cause ``OutOfMemoryError: Java heap space`` during indexing.
+
+    Both *initial_module* and *workspace_root* are resolved to real paths
+    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.
+    if not current.is_relative_to(workspace_root):
+        return workspace_root
+    while True:
+        pom = current / "pom.xml"
+        if pom.is_file():
+            try:
+                if "<modules>" in pom.read_text(encoding="utf-8", errors="ignore"):
+                    return current
+            except OSError:
+                pass
+        if current in (workspace_root, current.parent):
+            break
+        current = current.parent
+    return workspace_root
+
+
 @lru_cache(maxsize=256)
 def _module_snapshot_path(module_uri: str) -> Path:
     """Return the path for the persistent snapshot file for *module_uri*.
@@ -494,6 +530,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.
 
@@ -711,6 +763,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", {})
@@ -862,16 +915,34 @@ class JdtlsProxy:
         return module_uri
 
     async def expand_full_workspace(self) -> None:
-        """Expand jdtls workspace to the full monorepo root (background task).
+        """Expand jdtls workspace to the nearest Maven module-group root.
 
-        Removes the initial module-scoped folder and adds the full root to
-        avoid double-indexing.
+        Instead of expanding all the way to the IDE workspace root (which may
+        contain hundreds of Maven modules and cause jdtls OOM), this walks up
+        from the initial module to find the *nearest* ancestor directory whose
+        ``pom.xml`` declares ``<modules>`` — i.e. the tightest multi-module
+        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.
+
+        Removes all individually-added module folders to avoid double-indexing
+        with the newly added group root.
         """
         if self._workspace_expanded or not self._available or not self._original_root_uri:
             return
         from pygls.uris import from_fs_path, to_fs_path
 
-        root_path = to_fs_path(self._original_root_uri) or self._original_root_uri
+        workspace_path = to_fs_path(self._original_root_uri) or self._original_root_uri
+
+        # Find the tightest multi-module Maven parent of the initial module.
+        group_root_path: str = workspace_path
+        if self._initial_module_uri:
+            initial_path = to_fs_path(self._initial_module_uri) or self._initial_module_uri
+            group_root_path = str(_find_maven_group_root(Path(initial_path), Path(workspace_path)))
+
+        root_path = group_root_path
         root_uri = from_fs_path(root_path) or self._original_root_uri
         if self.modules.was_added(root_uri):
             self._workspace_expanded = True
@@ -887,7 +958,7 @@ class JdtlsProxy:
                 p = to_fs_path(uri) or uri
                 removed.append({"uri": uri, "name": Path(p).name})
 
-        logger.info("jdtls: expanding to full workspace %s", _redact_path(root_path))
+        logger.info("jdtls: expanding workspace to module group %s", _redact_path(root_path))
         await self.send_notification(
             _WORKSPACE_DID_CHANGE_FOLDERS,
             {"event": {"added": [{"uri": root_uri, "name": Path(root_path).name}], "removed": removed}},

{java_functional_lsp-0.9.1 → java_functional_lsp-0.9.3}/tests/test_proxy.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import subprocess
+from pathlib import Path
 from typing import Any
 from unittest.mock import MagicMock, patch
 
@@ -850,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}"})
 
@@ -858,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."""
@@ -1037,6 +1100,65 @@ class TestLazyStart:
             assert result2 is None  # Already known
             assert proxy.send_notification.call_count == 1  # type: ignore[attr-defined]
 
+    async def test_expand_uses_maven_group_root_not_workspace_root(self, tmp_path: Path) -> None:
+        """expand_full_workspace expands to nearest multi-module Maven parent, not the full IDE root."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        # Layout: workspace/group/module  — group/pom.xml has <modules>
+        workspace = tmp_path / "workspace"
+        group = workspace / "group"
+        module = group / "module"
+        module.mkdir(parents=True)
+        (group / "pom.xml").write_text("<project><modules><module>module</module></modules></project>")
+        (workspace / "pom.xml").write_text("<project><modules><module>group</module></modules></project>")
+
+        module_uri = module.as_uri()
+        workspace_uri = workspace.as_uri()
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = workspace_uri
+        proxy._initial_module_uri = module_uri
+        proxy.modules.mark_added(module_uri)
+        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"]
+        # Should expand to group/, NOT workspace/
+        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."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        # Flat layout: workspace/module — no intermediate pom.xml
+        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").write_text("<project><modules><module>module</module></modules></project>")
+
+        module_uri = module.as_uri()
+        workspace_uri = workspace.as_uri()
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = workspace_uri
+        proxy._initial_module_uri = module_uri
+        proxy.modules.mark_added(module_uri)
+        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
+
     async def test_expand_full_workspace_sends_notification(self) -> None:
         from unittest.mock import AsyncMock
 
@@ -1107,7 +1229,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
 
@@ -1131,7 +1254,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
 
@@ -1155,3 +1279,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