java-functional-lsp 0.7.8__tar.gz → 0.8.0__tar.gz

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.7.8
+Version: 0.8.0
 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
@@ -230,6 +230,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 **Options:**
 - `excludes` — glob patterns for files/directories to skip entirely (supports `**` for multi-segment wildcards)
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `suppressJdtlsPatterns` — list of regex patterns to suppress jdtls diagnostics (see below)
 
 **Spring-aware behavior:**
 - `throw-statement`, `catch-rethrow`, and `try-catch-to-monadic` are automatically suppressed inside `@Bean` methods
@@ -253,6 +254,37 @@ public String legacyMethod() { ... }
 
 Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
 
+### Lombok support
+
+Projects using [Lombok](https://projectlombok.org/) need the Lombok Java agent for jdtls to process `@Builder`, `@Value`, `@Data`, `@Slf4j`, and other annotations. Without it, jdtls reports false "method undefined" errors for generated methods.
+
+The server auto-discovers `lombok.jar` from these locations (first match wins):
+
+1. **Project config** — add to `.java-functional-lsp.json`:
+   ```json
+   { "lombok": "/path/to/lombok.jar" }
+   ```
+2. **Environment variable** — `LOMBOK_JAR=/path/to/lombok.jar`
+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`.
+
+### Suppressing jdtls diagnostics
+
+For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:
+
+```json
+{
+  "suppressJdtlsPatterns": [
+    "The method \\w+Mapper\\(\\) is undefined",
+    "cannot be resolved to a type"
+  ]
+}
+```
+
+Each entry is a regex matched against jdtls diagnostic messages. Invalid patterns are skipped with a warning.
+
 ## Code actions (quick fixes)
 
 The server provides LSP code actions (`textDocument/codeAction`) that automatically refactor code. When your editor shows a diagnostic with a lightbulb icon, clicking it applies the fix:

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/README.md

@@ -202,6 +202,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 **Options:**
 - `excludes` — glob patterns for files/directories to skip entirely (supports `**` for multi-segment wildcards)
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `suppressJdtlsPatterns` — list of regex patterns to suppress jdtls diagnostics (see below)
 
 **Spring-aware behavior:**
 - `throw-statement`, `catch-rethrow`, and `try-catch-to-monadic` are automatically suppressed inside `@Bean` methods
@@ -225,6 +226,37 @@ public String legacyMethod() { ... }
 
 Works on classes, methods, constructors, fields, and local variables. Suppression applies to the annotated scope — a class-level annotation suppresses all methods within it.
 
+### Lombok support
+
+Projects using [Lombok](https://projectlombok.org/) need the Lombok Java agent for jdtls to process `@Builder`, `@Value`, `@Data`, `@Slf4j`, and other annotations. Without it, jdtls reports false "method undefined" errors for generated methods.
+
+The server auto-discovers `lombok.jar` from these locations (first match wins):
+
+1. **Project config** — add to `.java-functional-lsp.json`:
+   ```json
+   { "lombok": "/path/to/lombok.jar" }
+   ```
+2. **Environment variable** — `LOMBOK_JAR=/path/to/lombok.jar`
+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`.
+
+### Suppressing jdtls diagnostics
+
+For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:
+
+```json
+{
+  "suppressJdtlsPatterns": [
+    "The method \\w+Mapper\\(\\) is undefined",
+    "cannot be resolved to a type"
+  ]
+}
+```
+
+Each entry is a regex matched against jdtls diagnostic messages. Invalid patterns are skipped with a warning.
+
 ## Code actions (quick fixes)
 
 The server provides LSP code actions (`textDocument/codeAction`) that automatically refactor code. When your editor shows a diagnostic with a lightbulb icon, clicking it applies the fix:

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/pyproject.toml

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

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/src/java_functional_lsp/__init__.py

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

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/src/java_functional_lsp/proxy.py

@@ -433,6 +433,81 @@ def _resolve_module_uri(file_uri: str) -> str | None:
     return module_uri or None
 
 
+def _version_key(name: str) -> tuple[int, ...]:
+    """Parse a version string into a tuple for semantic comparison."""
+    parts: list[int] = []
+    for segment in re.split(r"[.\-]", name):
+        try:
+            parts.append(int(segment))
+        except ValueError:
+            break
+    return tuple(parts)
+
+
+def _clear_cache_on_version_change(cache_root: Path) -> None:
+    """Clear jdtls data cache when the server version changes.
+
+    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.
+    """
+    from . import __version__
+
+    marker = cache_root / ".version"
+    try:
+        if marker.exists() and marker.read_text().strip() == __version__:
+            return
+        # 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__)
+        cache_root.mkdir(parents=True, exist_ok=True)
+        marker.write_text(__version__)
+    except OSError as e:
+        logger.warning("jdtls: failed to manage cache version marker: %s", e)
+
+
+def _find_lombok_jar(config: Mapping[str, Any] | None = None) -> str | None:
+    """Find lombok.jar from configurable and auto-discovered locations.
+
+    Search order (first match wins):
+    1. Project config (.java-functional-lsp.json): ``{"lombok": "/path/to/lombok.jar"}``
+    2. Environment variable: ``LOMBOK_JAR``
+    3. Maven cache: ``~/.m2/repository/org/projectlombok/lombok/*/lombok-*.jar``
+    4. Dedicated directory: ``~/.jdtls-libs/lombok.jar``
+    """
+    # 1. Project config
+    if config and config.get("lombok"):
+        p = Path(config["lombok"]).expanduser()
+        if p.is_file():
+            return str(p)
+        logger.warning("Lombok path from config does not exist: %s", _redact_path(str(p)))
+
+    # 2. Environment variable
+    env_path = os.environ.get("LOMBOK_JAR")
+    if env_path:
+        p = Path(env_path).expanduser()
+        if p.is_file():
+            return str(p)
+        logger.warning("LOMBOK_JAR does not exist: %s", _redact_path(env_path))
+
+    # 3. Maven cache (latest version, semantic sort)
+    m2_lombok = Path.home() / ".m2" / "repository" / "org" / "projectlombok" / "lombok"
+    if m2_lombok.is_dir():
+        version_dirs = [d for d in m2_lombok.iterdir() if d.is_dir()]
+        for version_dir in sorted(version_dirs, key=lambda d: _version_key(d.name), reverse=True):
+            jar = version_dir / f"lombok-{version_dir.name}.jar"
+            if jar.is_file():
+                return str(jar)
+
+    # 4. Dedicated directory
+    fallback = Path.home() / ".jdtls-libs" / "lombok.jar"
+    if fallback.is_file():
+        return str(fallback)
+
+    return None
+
+
 class JdtlsProxy:
     """Manages a jdtls subprocess and provides async request/notification forwarding."""
 
@@ -457,6 +532,7 @@ class JdtlsProxy:
         self._original_root_uri: str | None = None
         self._initial_module_uri: str | None = None
         self.modules = ModuleRegistry()
+        self.has_lombok = False
         self._workspace_expanded = False
 
     @property
@@ -480,7 +556,13 @@ class JdtlsProxy:
             logger.warning("jdtls not found on PATH — running in standalone mode (custom rules only)")
         return self._jdtls_on_path
 
-    async def start(self, init_params: dict[str, Any], *, module_root_uri: str | None = None) -> bool:
+    async def start(
+        self,
+        init_params: dict[str, Any],
+        *,
+        module_root_uri: str | None = None,
+        config: Mapping[str, Any] | None = None,
+    ) -> bool:
         """Start jdtls subprocess and initialize it.
 
         If *module_root_uri* is provided, jdtls is scoped to that module for
@@ -491,20 +573,35 @@ class JdtlsProxy:
         if not jdtls_path:
             return False
 
-        # Data-dir hash: use module URI when scoped so each module gets its own
-        # clean jdtls state. This avoids loading a 2.5GB monorepo index when only
-        # one module is needed. Without expansion, each session is module-scoped,
-        # so the data-dir should match that scope.
         original_root: str = init_params.get("rootUri") or init_params.get("rootPath") or str(Path.cwd())
         self._original_root_uri = original_root
+        effective_root_uri = module_root_uri or original_root
+
+        # Mark ADDED before any await to prevent duplicate module additions
+        # from concurrent coroutines during the executor yield below.
+        self._initial_module_uri = module_root_uri
+        self.modules.mark_added(effective_root_uri)
+
+        # All blocking startup I/O in a single executor call: cache version check
+        # (may rmtree on upgrade), Lombok discovery, and jdtls env build.
+        cache_root = Path.home() / ".cache" / "jdtls-data"
+
+        def _blocking_startup() -> tuple[dict[str, str], str | None]:
+            _clear_cache_on_version_change(cache_root)
+            return build_jdtls_env(), _find_lombok_jar(config)
+
+        loop = asyncio.get_running_loop()
+        jdtls_env, lombok_jar = await loop.run_in_executor(None, _blocking_startup)
+        if lombok_jar:
+            logger.info("jdtls: using Lombok agent from %s", _redact_path(lombok_jar))
+
         hash_source = module_root_uri or original_root
         data_hash = hashlib.sha256(hash_source.encode()).hexdigest()[:12]
-        data_dir = Path.home() / ".cache" / "jdtls-data" / data_hash
+        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)
-        effective_root_uri = module_root_uri or original_root
         if module_root_uri:
             effective_params["rootUri"] = module_root_uri
             from pygls.uris import to_fs_path
@@ -521,20 +618,18 @@ class JdtlsProxy:
         ws = caps.setdefault("workspace", {})
         ws["workspaceFolders"] = True
 
-        # Track the initial module as already loaded (mark ADDED before await).
-        self._initial_module_uri = module_root_uri
-        self.modules.mark_added(effective_root_uri)
-
-        # Build a clean environment for jdtls.
-        loop = asyncio.get_running_loop()
-        jdtls_env = await loop.run_in_executor(None, build_jdtls_env)
+        jdtls_cmd: list[str] = [
+            jdtls_path,
+            "-data",
+            str(data_dir),
+            f"--jvm-arg=-Xmx{DEFAULT_JVM_MAX_HEAP}",
+        ]
+        if lombok_jar:
+            jdtls_cmd.append(f"--jvm-arg=-javaagent:{lombok_jar}")
 
         try:
             self._process = await asyncio.create_subprocess_exec(
-                jdtls_path,
-                "-data",
-                str(data_dir),
-                f"--jvm-arg=-Xmx{DEFAULT_JVM_MAX_HEAP}",
+                *jdtls_cmd,
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
@@ -563,13 +658,19 @@ class JdtlsProxy:
 
             await self.send_notification("initialized", {})
             self._available = True
+            self.has_lombok = lombok_jar is not None
             return True
 
         except (OSError, FileNotFoundError) as e:
             logger.error("Failed to start jdtls: %s", e)
             return False
 
-    async def ensure_started(self, init_params: dict[str, Any], file_uri: str) -> bool:
+    async def ensure_started(
+        self,
+        init_params: dict[str, Any],
+        file_uri: str,
+        config: Mapping[str, Any] | None = None,
+    ) -> bool:
         """Start jdtls lazily, scoped to the module containing *file_uri*.
 
         Thread-safe: uses asyncio.Lock to prevent double-start from rapid
@@ -596,7 +697,7 @@ class JdtlsProxy:
             self._starting = True
             try:
                 module_uri = _resolve_module_uri(file_uri)
-                started = await self.start(init_params, module_root_uri=module_uri)
+                started = await self.start(init_params, module_root_uri=module_uri, config=config)
                 if not started:
                     self._start_failed = True
                     self._start_failed_at = time.monotonic()

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/src/java_functional_lsp/server.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import re
 import sys
 from pathlib import Path
 from typing import Any
@@ -64,6 +65,7 @@ class JavaFunctionalLspServer(LanguageServer):
         self._config: dict[str, Any] = {}
         self._init_params: dict[str, Any] = {}
         self._proxy = JdtlsProxy(on_diagnostics=self._on_jdtls_diagnostics)
+        self._user_suppress_patterns: list[re.Pattern[str]] = []
 
     def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
         """Called when jdtls publishes diagnostics — merge with custom and re-publish.
@@ -197,14 +199,54 @@ def _jdtls_raw_to_lsp_diagnostics(raw_diagnostics: list[Any]) -> list[lsp.Diagno
     return result
 
 
+def _compile_user_patterns(config: dict[str, Any]) -> list[re.Pattern[str]]:
+    """Compile user-defined suppressJdtlsPatterns from config."""
+    raw = config.get("suppressJdtlsPatterns", [])
+    if not isinstance(raw, list):
+        logger.warning("suppressJdtlsPatterns must be a list of regex strings, got %s", type(raw).__name__)
+        return []
+    patterns: list[re.Pattern[str]] = []
+    for entry in raw:
+        if not isinstance(entry, str):
+            continue
+        try:
+            patterns.append(re.compile(entry))
+        except re.error as e:
+            logger.warning("Invalid suppressJdtlsPatterns regex %r: %s", entry, e)
+    return patterns
+
+
+def _is_jdtls_suppressed(diag: dict[str, Any], user_patterns: list[re.Pattern[str]]) -> bool:
+    """Check if a jdtls diagnostic matches a user-configured suppress pattern.
+
+    No built-in patterns — the root cause (stale jdtls caches) is fixed by
+    clearing the cache on version change. Users can still suppress specific
+    jdtls messages via suppressJdtlsPatterns in .java-functional-lsp.json.
+    """
+    if not user_patterns:
+        return False
+    msg = diag.get("message", "")
+    for pat in user_patterns:
+        if pat.search(msg):
+            return True
+    return False
+
+
 def _run_analysis(source: str, uri: str) -> list[lsp.Diagnostic]:
-    """Run custom analyzers on source text and merge with jdtls diagnostics."""
+    """Run custom analyzers on source text and merge with jdtls diagnostics.
+
+    jdtls processing is isolated: if it fails, custom diagnostics still publish.
+    """
     custom_diags = _analyze_document(source, uri)
 
     jdtls_diags: list[lsp.Diagnostic] = []
     if server._proxy.is_available:
-        raw = server._proxy.get_cached_diagnostics(uri)
-        jdtls_diags = _jdtls_raw_to_lsp_diagnostics(raw)
+        try:
+            raw = server._proxy.get_cached_diagnostics(uri)
+            raw = [d for d in raw if not _is_jdtls_suppressed(d, server._user_suppress_patterns)]
+            jdtls_diags = _jdtls_raw_to_lsp_diagnostics(raw)
+        except Exception as e:
+            logger.warning("jdtls diagnostic processing failed for %s: %s", uri, e)
 
     return jdtls_diags + custom_diags
 
@@ -232,6 +274,7 @@ def on_initialize(params: lsp.InitializeParams) -> lsp.InitializeResult:
         root = params.root_path
 
     server._config = _load_config(root)
+    server._user_suppress_patterns = _compile_user_patterns(server._config)
 
     return lsp.InitializeResult(
         capabilities=lsp.ServerCapabilities(
@@ -338,7 +381,10 @@ def _analyze_and_publish(uri: str) -> None:
 async def _deferred_validate(uri: str) -> None:
     """Debounced validation — waits before analyzing to batch rapid edits."""
     await asyncio.sleep(_DEBOUNCE_SECONDS)
-    _analyze_and_publish(uri)
+    try:
+        _analyze_and_publish(uri)
+    except Exception as e:
+        logger.error("Validation failed for %s: %s", uri, e)
 
 
 def _forward_or_queue(method: str, serialized: Any) -> None:
@@ -377,7 +423,10 @@ async def on_did_open(params: lsp.DidOpenTextDocumentParams) -> None:
             task.add_done_callback(_bg_tasks.discard)
 
     # Custom diagnostics always publish immediately — never blocked by jdtls.
-    _analyze_and_publish(uri)
+    try:
+        _analyze_and_publish(uri)
+    except Exception as e:
+        logger.error("Analysis failed on open for %s: %s", uri, e)
 
 
 @server.feature(lsp.TEXT_DOCUMENT_DID_CHANGE)
@@ -395,7 +444,10 @@ async def on_did_change(params: lsp.DidChangeTextDocumentParams) -> None:
 async def on_did_save(params: lsp.DidSaveTextDocumentParams) -> None:
     """Forward to jdtls and re-analyze immediately (no debounce on save)."""
     _forward_or_queue("textDocument/didSave", _serialize_params(params))
-    _analyze_and_publish(params.text_document.uri)
+    try:
+        _analyze_and_publish(params.text_document.uri)
+    except Exception as e:
+        logger.error("Analysis failed on save for %s: %s", params.text_document.uri, e)
 
 
 @server.feature(lsp.TEXT_DOCUMENT_DID_CLOSE)
@@ -419,7 +471,7 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
     are loaded on-demand via ``add_module_if_new()`` as files are opened.
     """
     try:
-        started = await server._proxy.ensure_started(server._init_params, file_uri)
+        started = await server._proxy.ensure_started(server._init_params, file_uri, config=server._config)
         if started:
             logger.info("jdtls proxy active — full Java language support enabled")
             await _register_jdtls_capabilities()

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/tests/test_proxy.py

@@ -1103,7 +1103,7 @@ class TestLazyStart:
         proxy._jdtls_on_path = True
         captured: dict[str, Any] = {}
 
-        async def capturing_start(params: Any, *, module_root_uri: str | None = None) -> bool:
+        async def capturing_start(params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
             captured["module_root_uri"] = module_root_uri
             return False
 
@@ -1127,7 +1127,7 @@ class TestLazyStart:
 
         captured: dict[str, Any] = {}
 
-        async def capturing_start(params: Any, *, module_root_uri: str | None = None) -> bool:
+        async def capturing_start(params: Any, *, module_root_uri: str | None = None, config: Any = None) -> bool:
             captured["module_root_uri"] = module_root_uri
             return False
 

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/tests/test_server.py

@@ -642,6 +642,222 @@ class TestServerInternals:
 
 
 # --------------------------------------------------------------------------
+# --------------------------------------------------------------------------
+# Lombok support tests
+# --------------------------------------------------------------------------
+
+
+class TestUserSuppressPatterns:
+    """Tests for configurable suppressJdtlsPatterns."""
+
+    def test_user_pattern_matches(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns, _is_jdtls_suppressed
+
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"The method generateReport\(\) is undefined"]})
+        diag = {"message": "The method generateReport() is undefined for the type InternalService"}
+        assert _is_jdtls_suppressed(diag, patterns) is True
+
+    def test_user_pattern_does_not_match_unrelated(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns, _is_jdtls_suppressed
+
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"The method generateReport\(\) is undefined"]})
+        diag = {"message": "The method foo() is undefined for the type String"}
+        assert _is_jdtls_suppressed(diag, patterns) is False
+
+    def test_no_patterns_passes_everything(self) -> None:
+        """With no user patterns, nothing is suppressed."""
+        from java_functional_lsp.server import _is_jdtls_suppressed
+
+        diag = {"message": "The method builder() is undefined for the type Foo"}
+        assert _is_jdtls_suppressed(diag, []) is False
+
+    def test_invalid_regex_skipped(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
+
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"valid", r"[invalid"]})
+        assert len(patterns) == 1
+        assert patterns[0].search("valid") is not None
+
+    def test_non_list_ignored(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
+
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": "not a list"})
+        assert patterns == []
+
+    def test_empty_config(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
+
+        patterns = _compile_user_patterns({})
+        assert patterns == []
+
+
+class TestJdtlsIsolation:
+    """Tests that jdtls failures don't suppress custom diagnostics."""
+
+    def test_jdtls_exception_does_not_suppress_custom_diags(self) -> None:
+        """If jdtls diagnostic processing throws, custom diagnostics still publish."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _run_analysis
+
+        java_source = "public class Foo { public String bar() { return null; } }"
+
+        with patch("java_functional_lsp.server.server") as mock_server:
+            mock_server._proxy.is_available = True
+            mock_server._proxy.get_cached_diagnostics.side_effect = RuntimeError("jdtls corrupt")
+            mock_server._user_suppress_patterns = []
+            mock_server._config = {}
+            mock_server._parser = __import__("java_functional_lsp.analyzers.base", fromlist=["get_parser"]).get_parser()
+
+            result = _run_analysis(java_source, "file:///test/Foo.java")
+
+        custom_diags = [d for d in result if d.source == "java-functional-lsp"]
+        assert len(custom_diags) > 0, "Custom diagnostics should publish even when jdtls fails"
+
+    def test_jdtls_unavailable_still_publishes_custom_diags(self) -> None:
+        """When jdtls is not available, custom diagnostics still publish."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _run_analysis
+
+        java_source = "public class Foo { public String bar() { return null; } }"
+
+        with patch("java_functional_lsp.server.server") as mock_server:
+            mock_server._proxy.is_available = False
+            mock_server._config = {}
+            mock_server._parser = __import__("java_functional_lsp.analyzers.base", fromlist=["get_parser"]).get_parser()
+
+            result = _run_analysis(java_source, "file:///test/Foo.java")
+
+        custom_diags = [d for d in result if d.source == "java-functional-lsp"]
+        assert len(custom_diags) > 0, "Custom diagnostics should publish without jdtls"
+
+    def test_analyze_and_publish_exception_does_not_crash_handler(self) -> None:
+        """Handler-level try/except prevents server crash when _analyze_and_publish raises."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _deferred_validate
+
+        with patch("java_functional_lsp.server._analyze_and_publish", side_effect=RuntimeError("boom")):
+            import asyncio
+
+            loop = asyncio.new_event_loop()
+            try:
+                # _deferred_validate should catch the exception and log, not raise
+                loop.run_until_complete(_deferred_validate("file:///test/Foo.java"))
+            finally:
+                loop.close()
+        # If we get here without exception, the handler caught it correctly
+
+
+class TestFindLombokJar:
+    """Tests for _find_lombok_jar()."""
+
+    def test_config_path_wins(self, tmp_path: Any) -> None:
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        jar = tmp_path / "lombok.jar"
+        jar.touch()
+        result = _find_lombok_jar({"lombok": str(jar)})
+        assert result == str(jar)
+
+    def test_env_var_used(self, tmp_path: Any, monkeypatch: Any) -> None:
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        jar = tmp_path / "lombok.jar"
+        jar.touch()
+        monkeypatch.setenv("LOMBOK_JAR", str(jar))
+        result = _find_lombok_jar()
+        assert result == str(jar)
+
+    def test_config_wins_over_env(self, tmp_path: Any, monkeypatch: Any) -> None:
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        config_jar = tmp_path / "config-lombok.jar"
+        config_jar.touch()
+        env_jar = tmp_path / "env-lombok.jar"
+        env_jar.touch()
+        monkeypatch.setenv("LOMBOK_JAR", str(env_jar))
+        result = _find_lombok_jar({"lombok": str(config_jar)})
+        assert result == str(config_jar)
+
+    def test_maven_cache_semantic_sort(self, tmp_path: Any, monkeypatch: Any) -> None:
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        monkeypatch.delenv("LOMBOK_JAR", raising=False)
+        m2 = tmp_path / ".m2" / "repository" / "org" / "projectlombok" / "lombok"
+        for v in ["1.18.4", "1.18.30", "1.9.2"]:
+            d = m2 / v
+            d.mkdir(parents=True)
+            (d / f"lombok-{v}.jar").touch()
+        monkeypatch.setattr("pathlib.Path.home", lambda: tmp_path)
+        result = _find_lombok_jar()
+        assert result is not None
+        assert "1.18.30" in result  # Semantic sort picks 1.18.30 over 1.9.2
+
+    def test_returns_none_when_nothing_found(self, tmp_path: Any, monkeypatch: Any) -> None:
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        monkeypatch.delenv("LOMBOK_JAR", raising=False)
+        monkeypatch.setattr("pathlib.Path.home", lambda: tmp_path)
+        result = _find_lombok_jar()
+        assert result is None
+
+    def test_warns_on_missing_config_path(self, tmp_path: Any, caplog: Any) -> None:
+        import logging
+
+        from java_functional_lsp.proxy import _find_lombok_jar
+
+        with caplog.at_level(logging.WARNING, logger="java_functional_lsp.proxy"):
+            _find_lombok_jar({"lombok": "/nonexistent/lombok.jar"})
+        assert any("does not exist" in r.getMessage() for r in caplog.records)
+
+
+class TestCacheClear:
+    """Tests for _clear_cache_on_version_change()."""
+
+    def test_clears_on_version_mismatch(self, tmp_path: Any) -> None:
+        from java_functional_lsp.proxy import _clear_cache_on_version_change
+
+        cache = tmp_path / "jdtls-data"
+        cache.mkdir()
+        stale_dir = cache / "abc123"
+        stale_dir.mkdir()
+        (cache / ".version").write_text("0.7.9")
+
+        _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__
+
+    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
+
+        cache = tmp_path / "jdtls-data"
+        cache.mkdir()
+        existing_dir = cache / "abc123"
+        existing_dir.mkdir()
+        (cache / ".version").write_text(__version__)
+
+        _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
+
+        cache = tmp_path / "jdtls-data"
+        _clear_cache_on_version_change(cache)
+
+        from java_functional_lsp import __version__
+
+        assert (cache / ".version").read_text() == __version__
+
+
 # Subprocess-based tests — zero mocks, real LSP transport
 # --------------------------------------------------------------------------
 

{java_functional_lsp-0.7.8 → java_functional_lsp-0.8.0}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.7.4"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },