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

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

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

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

{java_functional_lsp-0.9.10 → java_functional_lsp-0.9.11}/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.11}/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.11}/tests/test_server.py

@@ -1548,48 +1548,69 @@ class TestFindLombokJar:
 
 
 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() == _compute_cache_marker()
 
-        assert (cache / ".version").read_text() == __version__
-
-    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