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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.8.0
+Version: 0.8.1
 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
@@ -128,6 +128,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code

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

@@ -100,6 +100,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code

{java_functional_lsp-0.8.0 → java_functional_lsp-0.8.1}/editors/intellij/README.md

@@ -73,7 +73,7 @@ Project-level rules are configured via `.java-functional-lsp.json` in your proje
 
 ## Coexistence with IntelliJ's Java Support
 
-LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace it. Your custom functional programming diagnostics appear alongside IntelliJ's built-in inspections. No conflicts.
+The server automatically detects JetBrains IDEs and disables the jdtls proxy — IntelliJ provides its own Java language features (completions, hover, go-to-definition, compile errors). Only the 16 custom functional programming rules run, and they appear alongside IntelliJ's built-in inspections.
 
 ## Troubleshooting
 
@@ -85,6 +85,7 @@ LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace
 - Ensure the file mapping is set to Language: `Java`, Language ID: `java`
 - Check that `.java-functional-lsp.json` doesn't have rules set to `"off"`
 - Try restarting the language server: **Tools** → **Language Servers** → **Restart**
+- If diagnostics worked before but stopped, the jdtls proxy may be interfering. Set `JAVA_FUNCTIONAL_LSP_JDTLS=off` in the server command environment to force-disable jdtls. The server auto-detects JetBrains IDEs and disables jdtls by default (since IntelliJ provides native Java support), but this can be overridden with `JAVA_FUNCTIONAL_LSP_JDTLS=on`.
 
 ### PATH not found
 - IntelliJ may not inherit your shell's PATH. Use the full absolute path to the binary in the server command.

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

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

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

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

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

@@ -9,6 +9,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import re
 import sys
 from pathlib import Path
@@ -46,6 +47,10 @@ _ANALYZERS: list[Analyzer] = [
     FunctionalChecker(),
 ]
 
+# JetBrains IDE detection — all products contain one of these substrings in clientInfo.name.
+# When detected, jdtls is skipped because IntelliJ provides native Java language support.
+_JDTLS_SKIP_CLIENTS = ("IntelliJ", "JetBrains")
+
 #: LSP-aware cattrs converter. Unstructures to the LSP JSON shape
 #: (camelCase field names, discriminated unions, None-field pruning) and
 #: correspondingly structures from the same shape. Using a vanilla
@@ -66,6 +71,9 @@ class JavaFunctionalLspServer(LanguageServer):
         self._init_params: dict[str, Any] = {}
         self._proxy = JdtlsProxy(on_diagnostics=self._on_jdtls_diagnostics)
         self._user_suppress_patterns: list[re.Pattern[str]] = []
+        self._skip_jdtls: bool = False
+        self._skip_jdtls_registration: bool = False
+        self._init_generation: int = 0
 
     def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
         """Called when jdtls publishes diagnostics — merge with custom and re-publish.
@@ -199,6 +207,9 @@ def _jdtls_raw_to_lsp_diagnostics(raw_diagnostics: list[Any]) -> list[lsp.Diagno
     return result
 
 
+_MAX_PATTERN_LENGTH = 500  # Cap regex length to mitigate ReDoS from pathological patterns
+
+
 def _compile_user_patterns(config: dict[str, Any]) -> list[re.Pattern[str]]:
     """Compile user-defined suppressJdtlsPatterns from config."""
     raw = config.get("suppressJdtlsPatterns", [])
@@ -209,6 +220,9 @@ def _compile_user_patterns(config: dict[str, Any]) -> list[re.Pattern[str]]:
     for entry in raw:
         if not isinstance(entry, str):
             continue
+        if len(entry) > _MAX_PATTERN_LENGTH:
+            logger.warning("suppressJdtlsPatterns entry too long (%d chars, max %d)", len(entry), _MAX_PATTERN_LENGTH)
+            continue
         try:
             patterns.append(re.compile(entry))
         except re.error as e:
@@ -276,6 +290,38 @@ def on_initialize(params: lsp.InitializeParams) -> lsp.InitializeResult:
     server._config = _load_config(root)
     server._user_suppress_patterns = _compile_user_patterns(server._config)
 
+    # Determine jdtls mode: env var takes priority, then auto-detect JetBrains IDEs.
+    client_name = (params.client_info.name if params.client_info else "")[:200]
+    logger.info("LSP client: %s", client_name or "(unknown)")
+
+    # Reset flags so re-initialization (non-standard but defensive) starts clean.
+    # Bump generation so in-flight _register_jdtls_capabilities from a prior
+    # session detects the stale context and aborts.
+    global _jdtls_capabilities_registered
+    server._skip_jdtls = False
+    server._skip_jdtls_registration = False
+    server._init_generation += 1
+    _jdtls_capabilities_registered = False
+
+    jdtls_override = os.environ.get("JAVA_FUNCTIONAL_LSP_JDTLS", "").strip().lower()
+    if jdtls_override == "off":
+        server._skip_jdtls = True
+        logger.info("jdtls proxy disabled via JAVA_FUNCTIONAL_LSP_JDTLS=off")
+    elif jdtls_override == "on":
+        logger.info("jdtls proxy force-enabled via JAVA_FUNCTIONAL_LSP_JDTLS=on")
+    elif jdtls_override == "no-register":
+        server._skip_jdtls_registration = True
+        logger.info("jdtls dynamic registration disabled via JAVA_FUNCTIONAL_LSP_JDTLS=no-register")
+    elif jdtls_override:
+        logger.warning("Unknown JAVA_FUNCTIONAL_LSP_JDTLS value %r; expected off/on/no-register", jdtls_override)
+    elif any(token in client_name for token in _JDTLS_SKIP_CLIENTS):
+        server._skip_jdtls = True
+        logger.info(
+            "JetBrains IDE detected (%s) — skipping jdtls proxy "
+            "(IDE provides native Java support; override with JAVA_FUNCTIONAL_LSP_JDTLS=on)",
+            client_name,
+        )
+
     return lsp.InitializeResult(
         capabilities=lsp.ServerCapabilities(
             text_document_sync=lsp.TextDocumentSyncOptions(
@@ -302,6 +348,9 @@ async def on_initialized(params: lsp.InitializedParams) -> None:
         "java-functional-lsp initialized (rules: %s)",
         list(server._config.get("rules", {}).keys()) or "all defaults",
     )
+    if server._skip_jdtls:
+        logger.info("jdtls proxy disabled — custom rules only")
+        return
     if server._proxy.check_available():
         logger.info("jdtls found on PATH — will start lazily on first file open")
     else:
@@ -349,11 +398,15 @@ async def _register_jdtls_capabilities() -> None:
     ready, which suppresses the IDE's built-in diagnostic tooltips.
 
     Idempotent: safe to call multiple times (e.g., proxy restart).
+    Uses a generation counter to detect stale registrations from a prior
+    initialize cycle (defensive against non-standard re-initialization).
     """
     global _jdtls_capabilities_registered
     if _jdtls_capabilities_registered:
         return
 
+    generation = server._init_generation
+
     try:
         # Register handlers so pygls dispatches incoming requests to them.
         for method, handler in _JDTLS_HANDLERS.items():
@@ -362,6 +415,12 @@ async def _register_jdtls_capabilities() -> None:
         # Tell the client we now support these capabilities.
         registrations = _build_jdtls_registrations()
         await server.client_register_capability_async(lsp.RegistrationParams(registrations=registrations))
+
+        # Bail if a re-initialize happened while we were awaiting.
+        if generation != server._init_generation:
+            logger.info("Discarding stale jdtls capability registration (re-initialize detected)")
+            return
+
         _jdtls_capabilities_registered = True
         logger.info("Dynamically registered jdtls capabilities (hover, definition, references, completion, symbol)")
     except Exception:
@@ -389,6 +448,8 @@ async def _deferred_validate(uri: str) -> None:
 
 def _forward_or_queue(method: str, serialized: Any) -> None:
     """Forward a notification to jdtls if available, or queue it if starting."""
+    if server._skip_jdtls:
+        return
     if server._proxy.is_available:
         task = asyncio.create_task(server._proxy.send_notification(method, serialized))
         _bg_tasks.add(task)
@@ -406,14 +467,18 @@ async def on_did_open(params: lsp.DidOpenTextDocumentParams) -> None:
     didOpen response isn't delayed by jdtls cold-start.
     """
     uri = params.text_document.uri
-    serialized = _serialize_params(params)
 
-    if server._proxy.is_available:
+    if server._skip_jdtls:
+        # Skip all jdtls forwarding — custom diagnostics only.
+        pass
+    elif server._proxy.is_available:
         # Fast path: jdtls running. Forward didOpen + add module if new.
+        serialized = _serialize_params(params)
         await server._proxy.send_notification("textDocument/didOpen", serialized)
         await server._proxy.add_module_if_new(uri)
     elif server._proxy._jdtls_on_path and not server._proxy._start_failed:
         # Queue the didOpen (whether this is the first file or a subsequent one during startup).
+        serialized = _serialize_params(params)
         server._proxy.queue_notification("textDocument/didOpen", serialized)
         if not server._proxy._lazy_start_fired:
             # First file: kick off lazy start in background.
@@ -474,7 +539,10 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
         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()
+            if server._skip_jdtls_registration:
+                logger.info("Skipping dynamic capability registration (no-register mode)")
+            else:
+                await _register_jdtls_capabilities()
             await server._proxy.flush_queued_notifications()
     except Exception:
         logger.warning("jdtls lazy start failed", exc_info=True)

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

@@ -750,6 +750,100 @@ class TestJdtlsIsolation:
         # If we get here without exception, the handler caught it correctly
 
 
+class TestJdtlsSkipDetection:
+    """Tests for auto-detecting JetBrains IDEs and skipping jdtls."""
+
+    def _make_init_params(self, client_name: str | None = None) -> Any:
+        """Create minimal InitializeParams with optional client_info."""
+        return lsp.InitializeParams(
+            capabilities=lsp.ClientCapabilities(),
+            root_uri="file:///tmp/test",
+            client_info=lsp.ClientInfo(name=client_name) if client_name else None,
+        )
+
+    def _run_init(self, monkeypatch: Any, client_name: str | None, env_value: str | None = None) -> None:
+        """Run on_initialize with controlled env and client_info."""
+        from java_functional_lsp.server import on_initialize, server
+
+        server._skip_jdtls = False
+        server._skip_jdtls_registration = False
+        if env_value is not None:
+            monkeypatch.setenv("JAVA_FUNCTIONAL_LSP_JDTLS", env_value)
+        else:
+            monkeypatch.delenv("JAVA_FUNCTIONAL_LSP_JDTLS", raising=False)
+        on_initialize(self._make_init_params(client_name))
+
+    def test_intellij_client_info_skips_jdtls(self, monkeypatch: Any) -> None:
+        """IntelliJ IDEA detected → _skip_jdtls = True."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "IntelliJ IDEA")
+        assert server._skip_jdtls is True
+
+    def test_jetbrains_product_skips_jdtls(self, monkeypatch: Any) -> None:
+        """Any JetBrains product detected → _skip_jdtls = True."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "JetBrains Rider 2025.2")
+        assert server._skip_jdtls is True
+
+    def test_vscode_allows_jdtls(self, monkeypatch: Any) -> None:
+        """VS Code → _skip_jdtls = False (jdtls needed)."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code")
+        assert server._skip_jdtls is False
+
+    def test_no_client_info_allows_jdtls(self, monkeypatch: Any) -> None:
+        """No client_info → _skip_jdtls = False (safe default)."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, None)
+        assert server._skip_jdtls is False
+
+    def test_env_var_off_overrides_detection(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=off disables jdtls even for non-JetBrains client."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code", env_value="off")
+        assert server._skip_jdtls is True
+
+    def test_env_var_on_overrides_intellij_detection(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=on force-enables jdtls even for IntelliJ."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "IntelliJ IDEA", env_value="on")
+        assert server._skip_jdtls is False
+
+    def test_env_var_no_register(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=no-register keeps jdtls but skips registration."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code", env_value="no-register")
+        assert server._skip_jdtls is False
+        assert server._skip_jdtls_registration is True
+
+    def test_custom_diagnostics_publish_when_jdtls_skipped(self) -> None:
+        """Tree-sitter analysis works normally when jdtls is skipped."""
+        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._skip_jdtls = True
+            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 when jdtls is skipped"
+        assert any(d.code == "null-return" for d in custom_diags), "null-return diagnostic expected"
+
+
 class TestFindLombokJar:
     """Tests for _find_lombok_jar()."""
 

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

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.8.0"
+version = "0.8.1"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },
@@ -426,7 +426,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "9.0.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -437,9 +437,9 @@ dependencies = [
     { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]