java-functional-lsp 0.9.18__tar.gz → 0.10.0__tar.gz

{java_functional_lsp-0.9.18 → java_functional_lsp-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.18
+Version: 0.10.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

{java_functional_lsp-0.9.18 → java_functional_lsp-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.18"
+version = "0.10.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.9.18 → java_functional_lsp-0.10.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.9.18"
+__version__ = "0.10.0"

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/__init__.py

@@ -0,0 +1,21 @@
+"""Capability negotiation — splits jdtls features into static-advertised vs
+dynamically-registered based on what the LSP client claims to support."""
+
+from __future__ import annotations
+
+from .handler_wiring import HandlerWiring
+from .negotiator import CapabilityNegotiator, NegotiationResult
+from .probe import ClientCapabilityProbe
+from .registry import REGISTRY, CapabilityEntry, all_methods
+from .static_builder import StaticCapabilityBuilder
+
+__all__ = [
+    "REGISTRY",
+    "CapabilityEntry",
+    "CapabilityNegotiator",
+    "ClientCapabilityProbe",
+    "HandlerWiring",
+    "NegotiationResult",
+    "StaticCapabilityBuilder",
+    "all_methods",
+]

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/handler_wiring.py

@@ -0,0 +1,69 @@
+"""Wire jdtls passthrough handlers into pygls' feature dispatcher.
+
+When `server.feature(method)(handler)` is called, pygls registers the handler so
+incoming requests for that method reach our code. The same call also influences
+pygls' auto-advertised capabilities, but we're not relying on that — we own the
+ServerCapabilities object explicitly via StaticCapabilityBuilder.
+
+`wire_eager` and `wire_lazy` share their body. Different names exist so the
+call-site intent (during `on_initialize` vs after jdtls warm-up) is self-evident.
+That readability is the SRP win.
+
+Idempotency: pygls' FeatureManager raises FeatureAlreadyRegisteredError if a
+method is registered twice. Tests use a module-level `server` singleton across
+many initialize cycles, so we skip already-registered methods rather than
+re-raising. In production the same guard is harmless — the second call is just
+a no-op.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any
+
+from .registry import CapabilityEntry
+
+
+class HandlerWiring:
+    """Registers pygls feature handlers for capability entries."""
+
+    def __init__(self, server: Any, handlers: Mapping[str, Callable[..., Any]]) -> None:
+        self._server = server
+        self._handlers = handlers
+
+    def wire_eager(self, entries: Sequence[CapabilityEntry]) -> None:
+        """Wire handlers immediately (call from on_initialize for static features)."""
+        self._wire(entries)
+
+    def wire_lazy(self, entries: Sequence[CapabilityEntry]) -> None:
+        """Wire handlers after jdtls warm-up (call before client/registerCapability)."""
+        self._wire(entries)
+
+    def _wire(self, entries: Sequence[CapabilityEntry]) -> None:
+        for entry in entries:
+            for method in self._methods_for(entry):
+                handler = self._handlers.get(method)
+                if handler is None:
+                    continue
+                if self._already_registered(method):
+                    continue
+                self._server.feature(method)(handler)
+
+    def _already_registered(self, method: str) -> bool:
+        """Check whether pygls already has a handler bound for `method`.
+
+        We probe `server.protocol.fm._features` (pygls FeatureManager). If the
+        attribute path isn't there (custom server stand-ins in tests), assume
+        not-registered and let the caller proceed.
+        """
+        protocol = getattr(self._server, "protocol", None)
+        fm = getattr(protocol, "fm", None) if protocol is not None else None
+        features = getattr(fm, "_features", None) if fm is not None else None
+        if features is None:
+            return False
+        return method in features
+
+    @staticmethod
+    def _methods_for(entry: CapabilityEntry) -> tuple[str, ...]:
+        """Return parent method + any sub-methods that ride along with it."""
+        return (entry.lsp_method, *entry.sub_methods)

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/negotiator.py

@@ -0,0 +1,53 @@
+"""Decide which capabilities to advertise statically vs dynamically.
+
+Given the registry and a probe, split entries into two groups:
+- dynamic: client advertised dynamicRegistration support → register via
+  client/registerCapability after jdtls warms up. Preserves PR #44 behavior
+  (don't claim hover before jdtls is ready, so the IDE keeps showing its
+  own diagnostic tooltips).
+- static: client did not → advertise in the InitializeResult so clients that
+  ignore client/registerCapability (like Claude Code) still route correctly.
+
+This module is pure logic — no I/O, no mutation of pygls state. That keeps it
+trivially unit-testable with hand-built probes.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from .probe import ClientCapabilityProbe
+from .registry import REGISTRY, CapabilityEntry
+
+
+@dataclass(frozen=True)
+class NegotiationResult:
+    """Output of CapabilityNegotiator.negotiate.
+
+    static: entries to advertise in InitializeResult.ServerCapabilities.
+    dynamic: entries to register later via client/registerCapability.
+    """
+
+    static: tuple[CapabilityEntry, ...]
+    dynamic: tuple[CapabilityEntry, ...]
+
+
+class CapabilityNegotiator:
+    """Splits a capability registry into static/dynamic subsets per client probe."""
+
+    def __init__(
+        self,
+        probe: ClientCapabilityProbe,
+        registry: Sequence[CapabilityEntry] = REGISTRY,
+    ) -> None:
+        self._registry = tuple(registry)
+        self._probe = probe
+
+    def negotiate(self) -> NegotiationResult:
+        static: list[CapabilityEntry] = []
+        dynamic: list[CapabilityEntry] = []
+        for entry in self._registry:
+            target = dynamic if self._probe.supports_dynamic(entry.client_cap_path) else static
+            target.append(entry)
+        return NegotiationResult(static=tuple(static), dynamic=tuple(dynamic))

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/probe.py

@@ -0,0 +1,77 @@
+"""Read-only inspection of the client's declared capabilities.
+
+Pygls hands `on_initialize` a `lsp.InitializeParams` whose `capabilities` field is
+an attrs-based `ClientCapabilities` object. We walk a path like
+`("text_document", "hover")` and return whether the client opted in to LSP
+`dynamicRegistration` for that feature.
+
+We intentionally accept both attrs-dataclass shapes and dicts at every level
+because some clients send vendor-specific extensions as raw dicts that pygls
+leaves untouched. Returning `False` (rather than raising) on missing nodes
+matches the LSP spec's default: absence of `dynamicRegistration` means the
+client does not advertise support.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from functools import cache
+from typing import Any
+
+import lsprotocol.types as lsp
+
+
+class ClientCapabilityProbe:
+    """Wraps `params.capabilities` and answers per-feature support questions."""
+
+    def __init__(self, params: lsp.InitializeParams) -> None:
+        self._caps: Any = params.capabilities
+
+    def supports_dynamic(self, path: tuple[str, ...]) -> bool:
+        """Return True if the client claims dynamicRegistration support for `path`.
+
+        `path` walks into ClientCapabilities — e.g., ("text_document", "hover")
+        means `params.capabilities.text_document.hover.dynamic_registration`.
+        Empty path or a missing intermediate node yields False (no support).
+        """
+        if not path:
+            return False
+        node: Any = self._caps
+        for key in path:
+            node = _walk(node, key)
+            if node is None:
+                return False
+        return _read_dynamic_registration(node)
+
+
+def _walk(node: Any, key: str) -> Any:
+    """Get a child of `node` by `key`, supporting both attrs/dataclass and dict shapes."""
+    if node is None:
+        return None
+    if isinstance(node, Mapping):
+        # Try snake_case first, then the camelCase the wire protocol uses.
+        if key in node:
+            return node[key]
+        return node.get(_snake_to_camel(key))
+    return getattr(node, key, None)
+
+
+def _read_dynamic_registration(node: Any) -> bool:
+    """Return whether `node.dynamicRegistration` is truthy."""
+    if node is None:
+        return False
+    if isinstance(node, Mapping):
+        return bool(node.get("dynamic_registration") or node.get("dynamicRegistration"))
+    return bool(getattr(node, "dynamic_registration", None))
+
+
+@cache
+def _snake_to_camel(key: str) -> str:
+    """`text_document` -> `textDocument`. Idempotent for already-camel names.
+
+    Cached because the LSP key space is bounded (~20 field names) but this is
+    called per-segment, per-entry, per-initialize when a client sends raw-dict
+    capabilities — repeated string allocation otherwise.
+    """
+    head, *tail = key.split("_")
+    return head + "".join(part.capitalize() for part in tail)

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/registry.py

@@ -0,0 +1,191 @@
+"""Capability registry — single source of truth for jdtls-dependent LSP features.
+
+Each entry pairs an LSP method with everything needed to advertise it both ways:
+- statically in the InitializeResult.ServerCapabilities (for clients that
+  ignore client/registerCapability, e.g., Claude Code)
+- dynamically via client/registerCapability after jdtls warms up (for clients
+  that respect dynamic registration, e.g., VS Code, IntelliJ-LSP4IJ — preserves
+  PR #44 behavior of not suppressing IDE diagnostic tooltips).
+
+The registry is data only. Decision logic lives in negotiator.py.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+import lsprotocol.types as lsp
+
+_JAVA_SELECTOR = [lsp.TextDocumentFilterLanguage(language="java")]
+
+
+@dataclass(frozen=True)
+class CapabilityEntry:
+    """Metadata for one jdtls-dependent LSP capability.
+
+    Attributes:
+        id_suffix: Used to build the unique Registration.id for dynamic registration.
+        lsp_method: The LSP method this capability gates (e.g., "textDocument/hover").
+        static_field: Name of the kwarg on lsp.ServerCapabilities for static advertisement.
+        client_cap_path: Path to the client capability that signals dynamic-registration
+            support (e.g., ("text_document", "hover")). Compared against
+            params.capabilities at initialize time.
+        registration_options_factory: Builds the RegistrationOptions object used in
+            client/registerCapability for the dynamic path.
+        static_value_factory: Builds the value to assign to ServerCapabilities[static_field].
+            Most are simply `True`; some are options objects (CompletionOptions etc.).
+        sub_methods: LSP methods that share this capability's advertisement but need
+            their own pygls handler (e.g., callHierarchy/incomingCalls). These are
+            wired alongside lsp_method whenever the entry is activated (static or dynamic).
+    """
+
+    id_suffix: str
+    lsp_method: str
+    static_field: str
+    client_cap_path: tuple[str, ...]
+    registration_options_factory: Callable[[], Any]
+    static_value_factory: Callable[[], Any]
+    sub_methods: tuple[str, ...] = field(default_factory=tuple)
+
+
+REGISTRY: tuple[CapabilityEntry, ...] = (
+    CapabilityEntry(
+        id_suffix="completion",
+        lsp_method=lsp.TEXT_DOCUMENT_COMPLETION,
+        static_field="completion_provider",
+        client_cap_path=("text_document", "completion"),
+        registration_options_factory=lambda: lsp.CompletionRegistrationOptions(
+            document_selector=_JAVA_SELECTOR, trigger_characters=["."]
+        ),
+        static_value_factory=lambda: lsp.CompletionOptions(trigger_characters=["."]),
+    ),
+    CapabilityEntry(
+        id_suffix="hover",
+        lsp_method=lsp.TEXT_DOCUMENT_HOVER,
+        static_field="hover_provider",
+        client_cap_path=("text_document", "hover"),
+        registration_options_factory=lambda: lsp.HoverRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="definition",
+        lsp_method=lsp.TEXT_DOCUMENT_DEFINITION,
+        static_field="definition_provider",
+        client_cap_path=("text_document", "definition"),
+        registration_options_factory=lambda: lsp.DefinitionRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="references",
+        lsp_method=lsp.TEXT_DOCUMENT_REFERENCES,
+        static_field="references_provider",
+        client_cap_path=("text_document", "references"),
+        registration_options_factory=lambda: lsp.ReferenceRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="document-symbol",
+        lsp_method=lsp.TEXT_DOCUMENT_DOCUMENT_SYMBOL,
+        static_field="document_symbol_provider",
+        client_cap_path=("text_document", "document_symbol"),
+        registration_options_factory=lambda: lsp.DocumentSymbolRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="call-hierarchy",
+        lsp_method=lsp.TEXT_DOCUMENT_PREPARE_CALL_HIERARCHY,
+        static_field="call_hierarchy_provider",
+        client_cap_path=("text_document", "call_hierarchy"),
+        registration_options_factory=lambda: lsp.CallHierarchyRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+        sub_methods=(lsp.CALL_HIERARCHY_INCOMING_CALLS, lsp.CALL_HIERARCHY_OUTGOING_CALLS),
+    ),
+    CapabilityEntry(
+        id_suffix="signature-help",
+        lsp_method=lsp.TEXT_DOCUMENT_SIGNATURE_HELP,
+        static_field="signature_help_provider",
+        client_cap_path=("text_document", "signature_help"),
+        registration_options_factory=lambda: lsp.SignatureHelpRegistrationOptions(
+            document_selector=_JAVA_SELECTOR,
+            trigger_characters=["(", ","],
+            retrigger_characters=[")"],
+        ),
+        static_value_factory=lambda: lsp.SignatureHelpOptions(
+            trigger_characters=["(", ","], retrigger_characters=[")"]
+        ),
+    ),
+    CapabilityEntry(
+        id_suffix="implementation",
+        lsp_method=lsp.TEXT_DOCUMENT_IMPLEMENTATION,
+        static_field="implementation_provider",
+        client_cap_path=("text_document", "implementation"),
+        registration_options_factory=lambda: lsp.ImplementationRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="type-definition",
+        lsp_method=lsp.TEXT_DOCUMENT_TYPE_DEFINITION,
+        static_field="type_definition_provider",
+        client_cap_path=("text_document", "type_definition"),
+        registration_options_factory=lambda: lsp.TypeDefinitionRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="declaration",
+        lsp_method=lsp.TEXT_DOCUMENT_DECLARATION,
+        static_field="declaration_provider",
+        client_cap_path=("text_document", "declaration"),
+        registration_options_factory=lambda: lsp.DeclarationRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="document-highlight",
+        lsp_method=lsp.TEXT_DOCUMENT_DOCUMENT_HIGHLIGHT,
+        static_field="document_highlight_provider",
+        client_cap_path=("text_document", "document_highlight"),
+        registration_options_factory=lambda: lsp.DocumentHighlightRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+    ),
+    CapabilityEntry(
+        id_suffix="rename",
+        lsp_method=lsp.TEXT_DOCUMENT_RENAME,
+        static_field="rename_provider",
+        client_cap_path=("text_document", "rename"),
+        registration_options_factory=lambda: lsp.RenameRegistrationOptions(
+            document_selector=_JAVA_SELECTOR, prepare_provider=True
+        ),
+        static_value_factory=lambda: lsp.RenameOptions(prepare_provider=True),
+        sub_methods=(lsp.TEXT_DOCUMENT_PREPARE_RENAME,),
+    ),
+    CapabilityEntry(
+        id_suffix="type-hierarchy",
+        lsp_method=lsp.TEXT_DOCUMENT_PREPARE_TYPE_HIERARCHY,
+        static_field="type_hierarchy_provider",
+        client_cap_path=("text_document", "type_hierarchy"),
+        registration_options_factory=lambda: lsp.TypeHierarchyRegistrationOptions(document_selector=_JAVA_SELECTOR),
+        static_value_factory=lambda: True,
+        sub_methods=(lsp.TYPE_HIERARCHY_SUPERTYPES, lsp.TYPE_HIERARCHY_SUBTYPES),
+    ),
+    CapabilityEntry(
+        id_suffix="workspace-symbol",
+        lsp_method=lsp.WORKSPACE_SYMBOL,
+        static_field="workspace_symbol_provider",
+        client_cap_path=("workspace", "symbol"),
+        # Lambda kept (vs bare class) for consistency with the other entries' Callable[[], Any]
+        # contract — defends against a silent semantic change if WorkspaceSymbolRegistrationOptions
+        # ever gains a required constructor arg.
+        registration_options_factory=lambda: lsp.WorkspaceSymbolRegistrationOptions(),  # noqa: PLW0108
+        static_value_factory=lambda: True,
+    ),
+)
+
+
+def all_methods(entries: tuple[CapabilityEntry, ...] = REGISTRY) -> tuple[str, ...]:
+    """Return every LSP method (parent + sub) reachable from `entries`."""
+    methods: list[str] = []
+    for entry in entries:
+        methods.append(entry.lsp_method)
+        methods.extend(entry.sub_methods)
+    return tuple(methods)

java_functional_lsp-0.10.0/src/java_functional_lsp/capabilities/static_builder.py

@@ -0,0 +1,41 @@
+"""Assemble the lsp.ServerCapabilities returned in InitializeResult.
+
+Single responsibility: take the static-advertised entries from the negotiator and
+build a `ServerCapabilities` object combining them with the always-static base
+(text_document_sync + code_action_provider for our QuickFix custom diagnostics).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import lsprotocol.types as lsp
+
+from .registry import CapabilityEntry
+
+_TEXT_DOC_SYNC = lsp.TextDocumentSyncOptions(
+    open_close=True,
+    change=lsp.TextDocumentSyncKind.Full,
+    save=lsp.SaveOptions(include_text=True),
+)
+
+_CODE_ACTION_OPTIONS = lsp.CodeActionOptions(code_action_kinds=[lsp.CodeActionKind.QuickFix])
+
+
+class StaticCapabilityBuilder:
+    """Builds the ServerCapabilities object for the InitializeResult.
+
+    The base capabilities (text_document_sync, code_action_provider) are always
+    advertised because they are fully owned by this server (custom diagnostics
+    + QuickFix code actions) — they don't depend on jdtls warm-up.
+    """
+
+    def build(self, static_entries: Sequence[CapabilityEntry]) -> lsp.ServerCapabilities:
+        kwargs: dict[str, Any] = {
+            "text_document_sync": _TEXT_DOC_SYNC,
+            "code_action_provider": _CODE_ACTION_OPTIONS,
+        }
+        for entry in static_entries:
+            kwargs[entry.static_field] = entry.static_value_factory()
+        return lsp.ServerCapabilities(**kwargs)