java-functional-lsp 0.9.10__tar.gz → 0.9.12__tar.gz

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.10
+Version: 0.9.12
 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
@@ -270,7 +270,37 @@ The server auto-discovers `lombok.jar` from these locations (first match wins):
 3. **Maven cache** — auto-discovered from `~/.m2/repository/org/projectlombok/lombok/`
 4. **Dedicated directory** — `~/.jdtls-libs/lombok.jar`
 
-If Lombok is used in your project but the jar isn't found, the server logs a warning. The jdtls cache is automatically cleared on version upgrade, so adding Lombok support takes effect immediately after `brew upgrade`.
+If Lombok is used in your project but the jar isn't found, the server logs a warning.
+
+### jdtls settings
+
+The server sends Maven/Gradle settings to jdtls at startup via `initializationOptions.settings`. Defaults are optimized for Maven monorepos (Maven enabled, Gradle disabled, build artifact exclusions). Override via `.java-functional-lsp.json`:
+
+```json
+{
+  "jdtls": {
+    "settings": {
+      "java": {
+        "import": {
+          "maven": { "enabled": true },
+          "gradle": { "enabled": true },
+          "exclusions": ["**/node_modules/**", "**/target/**"]
+        },
+        "configuration": { "updateBuildConfiguration": "automatic" },
+        "maven": { "downloadSources": true }
+      }
+    }
+  }
+}
+```
+
+Custom settings fully replace the defaults (no merge). See the [jdtls Preferences reference](https://github.com/eclipse-jdtls/eclipse.jdt.ls/blob/main/org.eclipse.jdt.ls.core/src/org/eclipse/jdt/ls/core/internal/preferences/Preferences.java) for all available keys.
+
+### jdtls cache
+
+The jdtls Eclipse workspace index is cached in `~/.cache/jdtls-data/`. Warm starts (~10-20s) reuse this cache; cold starts (60-120s) rebuild from scratch. The cache is automatically invalidated when jdtls or Java is upgraded, but **not** when java-functional-lsp is upgraded — our Python code changes don't affect the Eclipse index.
+
+To force a clean rebuild: `rm -rf ~/.cache/jdtls-data/`
 
 ### Suppressing jdtls diagnostics
 

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/README.md

@@ -242,7 +242,37 @@ The server auto-discovers `lombok.jar` from these locations (first match wins):
 3. **Maven cache** — auto-discovered from `~/.m2/repository/org/projectlombok/lombok/`
 4. **Dedicated directory** — `~/.jdtls-libs/lombok.jar`
 
-If Lombok is used in your project but the jar isn't found, the server logs a warning. The jdtls cache is automatically cleared on version upgrade, so adding Lombok support takes effect immediately after `brew upgrade`.
+If Lombok is used in your project but the jar isn't found, the server logs a warning.
+
+### jdtls settings
+
+The server sends Maven/Gradle settings to jdtls at startup via `initializationOptions.settings`. Defaults are optimized for Maven monorepos (Maven enabled, Gradle disabled, build artifact exclusions). Override via `.java-functional-lsp.json`:
+
+```json
+{
+  "jdtls": {
+    "settings": {
+      "java": {
+        "import": {
+          "maven": { "enabled": true },
+          "gradle": { "enabled": true },
+          "exclusions": ["**/node_modules/**", "**/target/**"]
+        },
+        "configuration": { "updateBuildConfiguration": "automatic" },
+        "maven": { "downloadSources": true }
+      }
+    }
+  }
+}
+```
+
+Custom settings fully replace the defaults (no merge). See the [jdtls Preferences reference](https://github.com/eclipse-jdtls/eclipse.jdt.ls/blob/main/org.eclipse.jdt.ls.core/src/org/eclipse/jdt/ls/core/internal/preferences/Preferences.java) for all available keys.
+
+### jdtls cache
+
+The jdtls Eclipse workspace index is cached in `~/.cache/jdtls-data/`. Warm starts (~10-20s) reuse this cache; cold starts (60-120s) rebuild from scratch. The cache is automatically invalidated when jdtls or Java is upgraded, but **not** when java-functional-lsp is upgraded — our Python code changes don't affect the Eclipse index.
+
+To force a clean rebuild: `rm -rf ~/.cache/jdtls-data/`
 
 ### Suppressing jdtls diagnostics
 

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/pyproject.toml

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

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/src/java_functional_lsp/proxy.py

@@ -30,6 +30,27 @@ DEFAULT_JVM_MAX_HEAP = "4g"
 _STDERR_LINE_MAX = 1000
 _MAX_EXPANDED_GROUPS: int = 5  # hard cap on concurrent Maven group workspace folders (prevents jdtls OOM)
 
+# Default jdtls initialization settings.  Sent via initializationOptions.settings
+# so they apply BEFORE the Maven import scan (didChangeConfiguration is too late).
+# Users can override via .java-functional-lsp.json: {"jdtls": {"settings": {...}}}
+_DEFAULT_JDTLS_SETTINGS: dict[str, Any] = {
+    "java": {
+        "import": {
+            "maven": {"enabled": True},
+            "gradle": {"enabled": False},
+            "exclusions": [
+                "**/node_modules/**",
+                "**/.metadata/**",
+                "**/archetype-resources/**",
+                "**/META-INF/maven/**",
+                "**/target/**",
+            ],
+        },
+        "configuration": {"updateBuildConfiguration": "automatic"},
+        "maven": {"downloadSources": False},
+    }
+}
+
 #: Minimum Java major version required by jdtls 1.57+. Anything below this
 #: is rejected by the jdtls Python launcher with ``"jdtls requires at least
 #: Java 21"`` before the server even starts.
@@ -558,25 +579,43 @@ def _wipe_data_dir(data_dir: Path) -> None:
         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.
+def _compute_cache_marker() -> str:
+    """Compute a stable cache marker from jdtls version path + Java version.
 
-    Stores a ``.version`` marker in the cache root. On version mismatch
-    (e.g., Lombok agent added, jdtls config changed), wipes the entire
-    cache so jdtls re-indexes from scratch with the current configuration.
+    Our Python package version changes (pip upgrades) do NOT affect the jdtls
+    Eclipse workspace index — only jdtls binary upgrades or Java version
+    changes do.  Resolves through symlinks so Homebrew Cellar version changes
+    (e.g. ``/opt/homebrew/Cellar/jdtls/1.58.0/...``) are detected even when
+    the wrapper script at ``/opt/homebrew/bin/jdtls`` doesn't change.
     """
-    from . import __version__
+    parts: list[str] = []
+    jdtls_path = shutil.which("jdtls")
+    if jdtls_path:
+        resolved = str(Path(jdtls_path).resolve())
+        parts.append(hashlib.sha256(resolved.encode()).hexdigest()[:12])
+    parts.append(str(_MIN_JDTLS_JAVA_MAJOR))
+    return "|".join(parts)
+
+
+def _clear_cache_on_version_change(cache_root: Path) -> None:
+    """Clear jdtls data cache when the jdtls installation changes.
 
+    Stores a ``.version`` marker in the cache root.  The marker is derived
+    from the resolved jdtls binary path + Java version requirement — NOT
+    from our Python ``__version__``.  This preserves warm caches across
+    java-functional-lsp upgrades (which don't affect the Eclipse index).
+    """
+    current_marker = _compute_cache_marker()
     marker = cache_root / ".version"
     try:
-        if marker.exists() and marker.read_text().strip() == __version__:
+        if marker.exists() and marker.read_text().strip() == current_marker:
             return
-        # Version changed or first run — clear stale caches.
+        # jdtls or Java version changed, or first run — clear stale caches.
         if cache_root.exists():
             shutil.rmtree(cache_root)
-            logger.info("jdtls: cleared stale cache (version changed to %s)", __version__)
+            logger.info("jdtls: cleared stale cache (marker changed to %s)", current_marker)
         cache_root.mkdir(parents=True, exist_ok=True)
-        marker.write_text(__version__)
+        marker.write_text(current_marker)
     except OSError as e:
         logger.warning("jdtls: failed to manage cache version marker: %s", e)
 
@@ -622,6 +661,48 @@ def _find_lombok_jar(config: Mapping[str, Any] | None = None) -> str | None:
     return None
 
 
+def _build_effective_params(
+    init_params: dict[str, Any],
+    module_root_uri: str | None,
+    original_root: str,
+    config: Mapping[str, Any] | None,
+) -> dict[str, Any]:
+    """Build the ``initialize`` request params for jdtls.
+
+    Deep-copies *init_params*, scopes to *module_root_uri* if provided,
+    injects workspaceFolders capability, and injects Maven/Gradle settings
+    from *config* (or defaults) into ``initializationOptions.settings``.
+    """
+    from pygls.uris import to_fs_path
+
+    effective_params = copy.deepcopy(init_params)
+    if module_root_uri:
+        effective_params["rootUri"] = module_root_uri
+        effective_params["rootPath"] = to_fs_path(module_root_uri)
+        logger.info(
+            "jdtls: scoping to module %s (full root: %s)",
+            _redact_path(module_root_uri),
+            _redact_path(original_root),
+        )
+
+    # Inject workspaceFolders capability for later expansion.
+    caps = effective_params.setdefault("capabilities", {})
+    ws = caps.setdefault("workspace", {})
+    ws["workspaceFolders"] = True
+
+    # Inject jdtls Maven/Gradle settings into initializationOptions.
+    # Must be in initializationOptions (not didChangeConfiguration) so they
+    # apply before the Maven import scan starts.
+    jdtls_settings = copy.deepcopy(_DEFAULT_JDTLS_SETTINGS)
+    if config and "jdtls" in config and "settings" in config["jdtls"]:
+        jdtls_settings = copy.deepcopy(config["jdtls"]["settings"])
+    init_opts = effective_params.setdefault("initializationOptions", {})
+    init_opts["settings"] = jdtls_settings
+    logger.debug("jdtls: initializationOptions.settings = %s", jdtls_settings)
+
+    return effective_params
+
+
 class JdtlsProxy:
     """Manages a jdtls subprocess and provides async request/notification forwarding."""
 
@@ -724,23 +805,7 @@ class JdtlsProxy:
         data_dir = cache_root / data_hash
         data_dir.mkdir(parents=True, exist_ok=True)
 
-        # Deep copy to avoid mutating server._init_params.
-        effective_params = copy.deepcopy(init_params)
-        if module_root_uri:
-            effective_params["rootUri"] = module_root_uri
-            from pygls.uris import to_fs_path
-
-            effective_params["rootPath"] = to_fs_path(module_root_uri)
-            logger.info(
-                "jdtls: scoping to module %s (full root: %s)",
-                _redact_path(module_root_uri),
-                _redact_path(original_root),
-            )
-
-        # Inject workspaceFolders capability for later expansion.
-        caps = effective_params.setdefault("capabilities", {})
-        ws = caps.setdefault("workspace", {})
-        ws["workspaceFolders"] = True
+        effective_params = _build_effective_params(init_params, module_root_uri, original_root, config)
 
         jdtls_cmd: list[str] = [
             jdtls_path,

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/src/java_functional_lsp/server.py

@@ -12,6 +12,7 @@ import logging
 import os
 import re
 import sys
+import time
 from collections.abc import Coroutine
 from pathlib import Path
 from typing import Any
@@ -635,6 +636,24 @@ async def on_did_close(params: lsp.DidCloseTextDocumentParams) -> None:
     _forward_or_queue("textDocument/didClose", _serialize_params(params))
 
 
+_DIDCHANGE_CONFIG_COOLDOWN = 30.0  # seconds — rate-limit didChangeConfiguration forwarding
+_last_config_forward: float = 0.0
+
+
+@server.feature(lsp.WORKSPACE_DID_CHANGE_CONFIGURATION)
+def on_did_change_configuration(params: lsp.DidChangeConfigurationParams) -> None:
+    """Forward IDE configuration changes to jdtls (rate-limited)."""
+    global _last_config_forward
+    if not server._proxy.is_available:
+        return
+    now = time.monotonic()
+    if now - _last_config_forward < _DIDCHANGE_CONFIG_COOLDOWN:
+        logger.debug("jdtls: throttling didChangeConfiguration (%.0fs cooldown)", _DIDCHANGE_CONFIG_COOLDOWN)
+        return
+    _last_config_forward = now
+    _fire_and_forget(server._proxy.send_notification("workspace/didChangeConfiguration", _serialize_params(params)))
+
+
 async def _lazy_start_jdtls(file_uri: str) -> None:
     """Background task: start jdtls scoped to the module containing *file_uri*.
 

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/tests/test_proxy.py

@@ -1417,6 +1417,58 @@ class TestLazyStart:
 # ---------------------------------------------------------------------------
 
 
+class TestBuildEffectiveParams:
+    """Tests for _build_effective_params."""
+
+    def test_defaults_injected_when_no_config(self) -> None:
+        from java_functional_lsp.proxy import _build_effective_params
+
+        result = _build_effective_params({"rootUri": "file:///ws"}, None, "file:///ws", None)
+        settings = result["initializationOptions"]["settings"]
+        assert settings["java"]["import"]["maven"]["enabled"] is True
+        assert settings["java"]["import"]["gradle"]["enabled"] is False
+        assert "**/target/**" in settings["java"]["import"]["exclusions"]
+
+    def test_config_override_replaces_defaults(self) -> None:
+        from java_functional_lsp.proxy import _build_effective_params
+
+        custom = {"java": {"custom": "value"}}
+        config = {"jdtls": {"settings": custom}}
+        result = _build_effective_params({"rootUri": "file:///ws"}, None, "file:///ws", config)
+        settings = result["initializationOptions"]["settings"]
+        assert settings == {"java": {"custom": "value"}}
+        assert "import" not in settings.get("java", {})
+
+    def test_does_not_mutate_original_init_params(self) -> None:
+        from java_functional_lsp.proxy import _build_effective_params
+
+        original = {"rootUri": "file:///ws", "capabilities": {}}
+        _build_effective_params(original, "file:///mod", "file:///ws", None)
+        assert "initializationOptions" not in original
+        assert original["rootUri"] == "file:///ws"
+
+    def test_module_root_uri_scopes_root(self) -> None:
+        from java_functional_lsp.proxy import _build_effective_params
+
+        result = _build_effective_params({"rootUri": "file:///ws"}, "file:///mod", "file:///ws", None)
+        assert result["rootUri"] == "file:///mod"
+
+    def test_workspace_folders_capability_always_set(self) -> None:
+        from java_functional_lsp.proxy import _build_effective_params
+
+        result = _build_effective_params({"rootUri": "file:///ws"}, None, "file:///ws", None)
+        assert result["capabilities"]["workspace"]["workspaceFolders"] is True
+
+    def test_deepcopy_prevents_default_mutation(self) -> None:
+        from java_functional_lsp.proxy import _DEFAULT_JDTLS_SETTINGS, _build_effective_params
+
+        result = _build_effective_params({"rootUri": "file:///ws"}, None, "file:///ws", None)
+        # Mutate the returned settings
+        result["initializationOptions"]["settings"]["java"]["import"]["exclusions"].append("MUTATED")
+        # Module-level defaults must be unchanged
+        assert "MUTATED" not in _DEFAULT_JDTLS_SETTINGS["java"]["import"]["exclusions"]
+
+
 class TestWipeDataDir:
     def test_wipe_removes_directory(self, tmp_path: Path) -> None:
         """Directory is removed and info is logged."""

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.12}/tests/test_server.py

@@ -1547,49 +1547,114 @@ class TestFindLombokJar:
         assert any("does not exist" in r.getMessage() for r in caplog.records)
 
 
+class TestDidChangeConfiguration:
+    """Tests for workspace/didChangeConfiguration forwarding."""
+
+    def test_forwards_to_jdtls_when_available(self) -> None:
+        from unittest.mock import AsyncMock, patch
+
+        import java_functional_lsp.server as srv_mod
+        from java_functional_lsp.server import on_did_change_configuration, server
+
+        srv_mod._last_config_forward = 0.0  # reset cooldown
+        server._proxy._available = True
+        server._proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+        params = lsp.DidChangeConfigurationParams(settings={"java": {"autobuild": {"enabled": True}}})
+        with patch("java_functional_lsp.server._fire_and_forget") as mock_faf:
+            on_did_change_configuration(params)
+            mock_faf.assert_called_once()
+
+    def test_throttled_within_cooldown(self) -> None:
+        from unittest.mock import patch
+
+        import java_functional_lsp.server as srv_mod
+        from java_functional_lsp.server import on_did_change_configuration, server
+
+        server._proxy._available = True
+        import time
+
+        srv_mod._last_config_forward = time.monotonic()  # just sent
+        params = lsp.DidChangeConfigurationParams(settings={})
+        with patch("java_functional_lsp.server._fire_and_forget") as mock_faf:
+            on_did_change_configuration(params)
+            mock_faf.assert_not_called()
+
+    def test_skipped_when_proxy_unavailable(self) -> None:
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import on_did_change_configuration, server
+
+        server._proxy._available = False
+        params = lsp.DidChangeConfigurationParams(settings={})
+        with patch("java_functional_lsp.server._fire_and_forget") as mock_faf:
+            on_did_change_configuration(params)
+            mock_faf.assert_not_called()
+
+
 class TestCacheClear:
-    """Tests for _clear_cache_on_version_change()."""
+    """Tests for _clear_cache_on_version_change() and _compute_cache_marker()."""
 
     def test_clears_on_version_mismatch(self, tmp_path: Any) -> None:
-        from java_functional_lsp.proxy import _clear_cache_on_version_change
+        from java_functional_lsp.proxy import _clear_cache_on_version_change, _compute_cache_marker
 
         cache = tmp_path / "jdtls-data"
         cache.mkdir()
         stale_dir = cache / "abc123"
         stale_dir.mkdir()
-        (cache / ".version").write_text("0.7.9")
+        (cache / ".version").write_text("old-stale-marker")
 
         _clear_cache_on_version_change(cache)
 
         assert not stale_dir.exists(), "Stale data-dir should be cleared"
         assert cache.exists(), "Cache root should be recreated"
-        from java_functional_lsp import __version__
-
-        assert (cache / ".version").read_text() == __version__
+        assert (cache / ".version").read_text() == _compute_cache_marker()
 
-    def test_keeps_cache_on_same_version(self, tmp_path: Any) -> None:
-        from java_functional_lsp import __version__
-        from java_functional_lsp.proxy import _clear_cache_on_version_change
+    def test_keeps_cache_on_same_marker(self, tmp_path: Any) -> None:
+        from java_functional_lsp.proxy import _clear_cache_on_version_change, _compute_cache_marker
 
         cache = tmp_path / "jdtls-data"
         cache.mkdir()
         existing_dir = cache / "abc123"
         existing_dir.mkdir()
-        (cache / ".version").write_text(__version__)
+        (cache / ".version").write_text(_compute_cache_marker())
 
         _clear_cache_on_version_change(cache)
 
         assert existing_dir.exists(), "Existing data-dir should be preserved"
 
     def test_creates_marker_on_first_run(self, tmp_path: Any) -> None:
-        from java_functional_lsp.proxy import _clear_cache_on_version_change
+        from java_functional_lsp.proxy import _clear_cache_on_version_change, _compute_cache_marker
 
         cache = tmp_path / "jdtls-data"
         _clear_cache_on_version_change(cache)
 
-        from java_functional_lsp import __version__
+        assert (cache / ".version").read_text() == _compute_cache_marker()
+
+    def test_python_version_bump_preserves_cache(self) -> None:
+        """Our __version__ is NOT in the cache marker — pip upgrades don't wipe."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import _compute_cache_marker
+
+        marker_before = _compute_cache_marker()
+        with patch("java_functional_lsp.__version__", "99.99.99"):
+            marker_after = _compute_cache_marker()
+        assert marker_before == marker_after, "Changing __version__ must not change the cache marker"
+
+    def test_different_jdtls_paths_produce_different_markers(self) -> None:
+        """Different resolved jdtls paths produce different cache markers."""
+        from pathlib import Path
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import _compute_cache_marker
 
-        assert (cache / ".version").read_text() == __version__
+        with patch("java_functional_lsp.proxy.shutil.which", return_value="/opt/jdtls/1.57/bin/jdtls"):
+            with patch("java_functional_lsp.proxy.Path.resolve", return_value=Path("/opt/jdtls/1.57/bin/jdtls")):
+                marker_a = _compute_cache_marker()
+        with patch("java_functional_lsp.proxy.shutil.which", return_value="/opt/jdtls/1.58/bin/jdtls"):
+            with patch("java_functional_lsp.proxy.Path.resolve", return_value=Path("/opt/jdtls/1.58/bin/jdtls")):
+                marker_b = _compute_cache_marker()
+        assert marker_a != marker_b
 
 
 # Subprocess-based tests — zero mocks, real LSP transport