java-functional-lsp 0.1.0__tar.gz → 0.2.0__tar.gz

{java_functional_lsp-0.1.0 → java_functional_lsp-0.2.0}/.github/workflows/release-drafter.yml

@@ -3,17 +3,15 @@ name: Release Drafter
 on:
   push:
     branches: [main]
-  pull_request:
-    types: [opened, reopened, synchronize]
 
 permissions:
-  contents: read
+  contents: write
   pull-requests: write
 
 jobs:
   update-release-draft:
     runs-on: ubuntu-latest
     steps:
-      - uses: release-drafter/release-drafter@v6
+      - uses: release-drafter/release-drafter@v7
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

java_functional_lsp-0.2.0/.github/workflows/update-homebrew.yml

@@ -0,0 +1,61 @@
+name: Update Homebrew Formula
+
+on:
+  workflow_run:
+    workflows: ["Publish to PyPI"]
+    types: [completed]
+  workflow_dispatch:
+
+jobs:
+  update-formula:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' }}
+    steps:
+      - uses: actions/checkout@v6
+      - name: Get release version
+        id: version
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION=$(gh api "repos/${{ github.repository }}/releases/latest" --jq .tag_name)
+          echo "version=${VERSION#v}" >> "$GITHUB_OUTPUT"
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+      - name: Wait for PyPI availability
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          for i in $(seq 1 30); do
+            if pip index versions java-functional-lsp 2>/dev/null | grep -q "$PKG_VERSION"; then
+              echo "java-functional-lsp==$PKG_VERSION available on PyPI"
+              break
+            fi
+            echo "Waiting for PyPI... attempt $i/30"
+            sleep 20
+          done
+      - name: Generate formula
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          python3 scripts/generate-formula.py "$PKG_VERSION" > java-functional-lsp.rb
+          echo "Generated formula:"
+          cat java-functional-lsp.rb
+      - name: Checkout tap repo
+        uses: actions/checkout@v6
+        with:
+          repository: aviadshiber/homebrew-tap
+          token: ${{ secrets.TAP_GITHUB_TOKEN }}
+          path: homebrew-tap
+      - name: Update formula
+        env:
+          PKG_VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          cp java-functional-lsp.rb homebrew-tap/Formula/java-functional-lsp.rb
+          cd homebrew-tap
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/java-functional-lsp.rb
+          git diff --cached --quiet || git commit -m "Update java-functional-lsp to $PKG_VERSION"
+          git push

{java_functional_lsp-0.1.0 → java_functional_lsp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.1.0
+Version: 0.2.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
@@ -29,8 +29,8 @@ Description-Content-Type: text/markdown
 # java-functional-lsp
 
 [![CI](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml/badge.svg)](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml)
-[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp)](https://pypi.org/project/java-functional-lsp/)
-[![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp)](https://pypi.org/project/java-functional-lsp/)
+[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
+[![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
@@ -55,12 +55,13 @@ A Java Language Server that enforces functional programming best practices. Desi
 ## Install
 
 ```bash
-pip install java-functional-lsp
-```
+# Homebrew
+brew install aviadshiber/tap/java-functional-lsp
 
-Or from source:
+# pip
+pip install java-functional-lsp
 
-```bash
+# From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 ```
 

{java_functional_lsp-0.1.0 → java_functional_lsp-0.2.0}/README.md

@@ -1,8 +1,8 @@
 # java-functional-lsp
 
 [![CI](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml/badge.svg)](https://github.com/aviadshiber/java-functional-lsp/actions/workflows/test.yml)
-[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp)](https://pypi.org/project/java-functional-lsp/)
-[![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp)](https://pypi.org/project/java-functional-lsp/)
+[![PyPI version](https://img.shields.io/pypi/v/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
+[![Python](https://img.shields.io/pypi/pyversions/java-functional-lsp?v=1)](https://pypi.org/project/java-functional-lsp/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 A Java Language Server that enforces functional programming best practices. Designed for teams using **Vavr**, **Lombok**, and **Spring** with a functional-first approach.
@@ -27,12 +27,13 @@ A Java Language Server that enforces functional programming best practices. Desi
 ## Install
 
 ```bash
-pip install java-functional-lsp
-```
+# Homebrew
+brew install aviadshiber/tap/java-functional-lsp
 
-Or from source:
+# pip
+pip install java-functional-lsp
 
-```bash
+# From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
 ```
 

{java_functional_lsp-0.1.0 → java_functional_lsp-0.2.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling==1.28.0"]
+requires = ["hatchling==1.29.0"]
 build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.1.0"
+version = "0.2.0"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }
@@ -38,7 +38,7 @@ Repository = "https://github.com/aviadshiber/java-functional-lsp"
 Changelog = "https://github.com/aviadshiber/java-functional-lsp/releases"
 
 [project.scripts]
-java-functional-lsp = "java_functional_lsp.server:main"
+java-functional-lsp = "java_functional_lsp.cli:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/java_functional_lsp"]
@@ -50,6 +50,7 @@ package = true
 [dependency-groups]
 dev = [
     "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
     "pytest-cov>=4.0.0",
     "pytest-mock>=3.12.0",
     "ruff>=0.1.0",
@@ -62,6 +63,7 @@ python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
 addopts = "--cov=java_functional_lsp --cov-report=term-missing --cov-fail-under=60"
+asyncio_mode = "auto"
 
 [tool.ruff]
 line-length = 120
@@ -75,6 +77,7 @@ ignore = ["PLR0913", "PLC0415", "PLW0603", "PLW0602"]
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["E402"]
 "**/test_*.py" = ["PLR2004"]
+"**/cli.py" = ["T20", "PLR0912", "PLR2004"]
 
 [tool.ruff.format]
 quote-style = "double"

java_functional_lsp-0.2.0/scripts/generate-formula.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Generate a Homebrew formula for java-functional-lsp.
+
+Usage: python3 scripts/generate-formula.py <version>
+"""
+from __future__ import annotations
+
+import json
+import sys
+import urllib.request
+
+
+def get_pypi_sha256(package: str, version: str) -> str:
+    """Get the sdist sha256 for a package from PyPI."""
+    url = f"https://pypi.org/pypi/{package}/{version}/json"
+    with urllib.request.urlopen(url) as resp:
+        data = json.loads(resp.read())
+
+    for file_info in data.get("urls", []):
+        if file_info["filename"].endswith(".tar.gz"):
+            return file_info["digests"]["sha256"]
+
+    for file_info in data.get("urls", []):
+        if file_info["packagetype"] == "sdist":
+            return file_info["digests"]["sha256"]
+
+    raise ValueError(f"No sdist found for {package}=={version}")
+
+
+def generate_formula(version: str) -> str:
+    """Generate the Homebrew formula."""
+    sha256 = get_pypi_sha256("java-functional-lsp", version)
+
+    return f'''class JavaFunctionalLsp < Formula
+  desc "Java LSP server enforcing functional programming best practices"
+  homepage "https://github.com/aviadshiber/java-functional-lsp"
+  url "https://files.pythonhosted.org/packages/source/j/java-functional-lsp/java_functional_lsp-{version}.tar.gz"
+  sha256 "{sha256}"
+  license "MIT"
+
+  depends_on "python@3.12"
+
+  def install
+    python3 = "python3.12"
+    venv = libexec/"venv"
+    system python3, "-m", "venv", venv
+    system venv/"bin/pip", "install", "--upgrade", "pip"
+    system venv/"bin/pip", "install", buildpath
+    bin.install_symlink Dir[venv/"bin/java-functional-lsp"]
+  end
+
+  test do
+    assert_match "java-functional-lsp", shell_output("#{{bin}}/java-functional-lsp --help 2>&1", 1)
+  end
+end
+'''
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <version>", file=sys.stderr)
+        sys.exit(1)
+    print(generate_formula(sys.argv[1]))

{java_functional_lsp-0.1.0 → java_functional_lsp-0.2.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.1.0"
+__version__ = "0.2.0"

java_functional_lsp-0.2.0/src/java_functional_lsp/cli.py

@@ -0,0 +1,121 @@
+"""CLI check mode — run java-functional-lsp as a standalone linter without LSP."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from .analyzers.base import Analyzer, Diagnostic, Severity, get_parser
+from .analyzers.exception_checker import ExceptionChecker
+from .analyzers.mutation_checker import MutationChecker
+from .analyzers.null_checker import NullChecker
+from .analyzers.spring_checker import SpringChecker
+
+_ANALYZERS: list[Analyzer] = [NullChecker(), ExceptionChecker(), MutationChecker(), SpringChecker()]
+
+_SEVERITY_SYMBOLS = {
+    Severity.ERROR: "E",
+    Severity.WARNING: "W",
+    Severity.INFO: "I",
+    Severity.HINT: "H",
+}
+
+
+def load_config(start_path: Path) -> dict[str, Any]:
+    """Walk up from start_path to find .deeperdive-linter.json."""
+    current = start_path if start_path.is_dir() else start_path.parent
+    while current != current.parent:
+        config_path = current / ".deeperdive-linter.json"
+        if config_path.exists():
+            try:
+                result: dict[str, Any] = json.loads(config_path.read_text())
+                return result
+            except (json.JSONDecodeError, OSError):
+                pass
+        current = current.parent
+    return {}
+
+
+def check_file(path: Path, config: dict[str, Any]) -> list[Diagnostic]:
+    """Analyze a single Java file and return diagnostics."""
+    parser = get_parser()
+    source = path.read_bytes()
+    tree = parser.parse(source)
+
+    all_diags: list[Diagnostic] = []
+    for analyzer in _ANALYZERS:
+        diags = analyzer.analyze(tree, source, config)
+        all_diags.extend(diags)
+
+    all_diags.sort(key=lambda d: (d.line, d.col))
+    return all_diags
+
+
+def format_diagnostic(path: Path, d: Diagnostic) -> str:
+    """Format a diagnostic as a single line: path:line:col: [S] code: message."""
+    sym = _SEVERITY_SYMBOLS.get(d.severity, "W")
+    return f"{path}:{d.line + 1}:{d.col}: [{sym}] {d.code}: {d.message}"
+
+
+def main() -> None:
+    """CLI entry point: java-functional-lsp check <files...>"""
+    args = sys.argv[1:]
+
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: java-functional-lsp check <file.java> [file2.java ...]")
+        print("       java-functional-lsp check --dir <directory>")
+        print("       java-functional-lsp          (start LSP server on stdio)")
+        sys.exit(0)
+
+    if args[0] != "check":
+        # Not check mode — fall through to LSP server
+        from .server import main as lsp_main
+
+        lsp_main()
+        return
+
+    args = args[1:]  # skip "check"
+
+    # Collect files
+    files: list[Path] = []
+    if args and args[0] == "--dir":
+        if len(args) < 2:
+            print("Error: --dir requires a directory path", file=sys.stderr)
+            sys.exit(1)
+        directory = Path(args[1])
+        if not directory.is_dir():
+            print(f"Error: {directory} is not a directory", file=sys.stderr)
+            sys.exit(1)
+        files = sorted(directory.rglob("*.java"))
+    else:
+        for arg in args:
+            p = Path(arg)
+            if p.is_file():
+                files.append(p)
+            elif p.is_dir():
+                files.extend(sorted(p.rglob("*.java")))
+            else:
+                print(f"Warning: {arg} not found, skipping", file=sys.stderr)
+
+    if not files:
+        print("No .java files found", file=sys.stderr)
+        sys.exit(1)
+
+    # Load config from first file's directory
+    config = load_config(files[0])
+
+    total_diags = 0
+    for path in files:
+        diags = check_file(path, config)
+        for d in diags:
+            print(format_diagnostic(path, d))
+        total_diags += len(diags)
+
+    if total_diags > 0:
+        print(f"\n{total_diags} diagnostic(s) in {len(files)} file(s)", file=sys.stderr)
+        sys.exit(1)
+    else:
+        print(f"No issues found in {len(files)} file(s)", file=sys.stderr)
+        sys.exit(0)

java_functional_lsp-0.2.0/src/java_functional_lsp/proxy.py

@@ -0,0 +1,235 @@
+"""jdtls proxy — manages a jdtls subprocess and forwards LSP messages via JSON-RPC over stdio."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import shutil
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+REQUEST_TIMEOUT = 30.0  # seconds
+
+
+def encode_message(body: dict[str, Any]) -> bytes:
+    """Encode a JSON-RPC message with Content-Length header."""
+    content = json.dumps(body).encode("utf-8")
+    header = f"Content-Length: {len(content)}\r\n\r\n".encode("ascii")
+    return header + content
+
+
+async def read_message(reader: asyncio.StreamReader) -> dict[str, Any] | None:
+    """Read a Content-Length framed JSON-RPC message from a stream."""
+    try:
+        # Read headers until blank line
+        content_length = -1
+        while True:
+            line = await reader.readline()
+            if not line:
+                return None  # EOF
+            line_str = line.decode("ascii").strip()
+            if not line_str:
+                break  # End of headers
+            if line_str.lower().startswith("content-length:"):
+                content_length = int(line_str.split(":", 1)[1].strip())
+
+        if content_length < 0:
+            return None
+
+        # Read body
+        body_bytes = await reader.readexactly(content_length)
+        result: dict[str, Any] = json.loads(body_bytes)
+        return result
+    except (asyncio.IncompleteReadError, ConnectionError, OSError):
+        return None
+
+
+class JdtlsProxy:
+    """Manages a jdtls subprocess and provides async request/notification forwarding."""
+
+    def __init__(self, on_diagnostics: Callable[[str, list[Any]], None] | None = None) -> None:
+        self._process: asyncio.subprocess.Process | None = None
+        self._reader_task: asyncio.Task[None] | None = None
+        self._next_id: int = 1
+        self._pending: dict[int, asyncio.Future[Any]] = {}
+        self._diagnostics_cache: dict[str, list[Any]] = {}
+        self._on_diagnostics = on_diagnostics
+        self._available = False
+        self._jdtls_capabilities: dict[str, Any] = {}
+
+    @property
+    def is_available(self) -> bool:
+        """Whether jdtls is running and responsive."""
+        return self._available
+
+    @property
+    def capabilities(self) -> dict[str, Any]:
+        """jdtls server capabilities from initialize response."""
+        return self._jdtls_capabilities
+
+    def get_cached_diagnostics(self, uri: str) -> list[Any]:
+        """Get the latest jdtls diagnostics for a URI."""
+        return list(self._diagnostics_cache.get(uri, []))
+
+    async def start(self, init_params: dict[str, Any]) -> bool:
+        """Start jdtls subprocess and initialize it."""
+        jdtls_path = shutil.which("jdtls")
+        if not jdtls_path:
+            logger.warning("jdtls not found on PATH — running in standalone mode (custom rules only)")
+            return False
+
+        try:
+            self._process = await asyncio.create_subprocess_exec(
+                jdtls_path,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            logger.info("jdtls subprocess started (pid=%s)", self._process.pid)
+
+            # Start background reader
+            assert self._process.stdout is not None
+            self._reader_task = asyncio.create_task(self._reader_loop(self._process.stdout))
+
+            # Send initialize request
+            result = await self.send_request("initialize", init_params)
+            if result is None:
+                logger.error("jdtls initialize request failed or timed out")
+                await self.stop()
+                return False
+
+            self._jdtls_capabilities = result.get("capabilities", {})
+            logger.info("jdtls initialized (capabilities: %s)", list(self._jdtls_capabilities.keys()))
+
+            # Send initialized notification
+            await self.send_notification("initialized", {})
+            self._available = True
+            return True
+
+        except (OSError, FileNotFoundError) as e:
+            logger.error("Failed to start jdtls: %s", e)
+            return False
+
+    async def stop(self) -> None:
+        """Shutdown jdtls subprocess gracefully."""
+        self._available = False
+
+        if self._reader_task and not self._reader_task.done():
+            self._reader_task.cancel()
+
+        if self._process and self._process.returncode is None:
+            try:
+                await self.send_request("shutdown", None, timeout=5.0)
+                await self.send_notification("exit", None)
+                await asyncio.wait_for(self._process.wait(), timeout=5.0)
+            except (asyncio.TimeoutError, OSError):
+                self._process.kill()
+                await self._process.wait()
+
+        # Cancel all pending requests
+        for future in self._pending.values():
+            if not future.done():
+                future.cancel()
+        self._pending.clear()
+
+    async def send_request(self, method: str, params: Any, timeout: float = REQUEST_TIMEOUT) -> Any | None:
+        """Send a JSON-RPC request and wait for the response."""
+        if not self._process or self._process.stdin is None:
+            return None
+
+        request_id = self._next_id
+        self._next_id += 1
+
+        msg: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+        }
+        if params is not None:
+            msg["params"] = params
+
+        future: asyncio.Future[Any] = asyncio.get_event_loop().create_future()
+        self._pending[request_id] = future
+
+        try:
+            self._process.stdin.write(encode_message(msg))
+            await self._process.stdin.drain()
+            result = await asyncio.wait_for(future, timeout=timeout)
+            return result
+        except asyncio.TimeoutError:
+            logger.warning("jdtls request %s timed out after %.1fs", method, timeout)
+            self._pending.pop(request_id, None)
+            return None
+        except (OSError, ConnectionError) as e:
+            logger.error("jdtls communication error on %s: %s", method, e)
+            self._pending.pop(request_id, None)
+            self._available = False
+            return None
+
+    async def send_notification(self, method: str, params: Any) -> None:
+        """Send a JSON-RPC notification (no response expected)."""
+        if not self._process or self._process.stdin is None:
+            return
+
+        msg: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "method": method,
+        }
+        if params is not None:
+            msg["params"] = params
+
+        try:
+            self._process.stdin.write(encode_message(msg))
+            await self._process.stdin.drain()
+        except (OSError, ConnectionError) as e:
+            logger.error("jdtls notification error on %s: %s", method, e)
+            self._available = False
+
+    async def _reader_loop(self, reader: asyncio.StreamReader) -> None:
+        """Background task: read jdtls stdout and dispatch messages."""
+        try:
+            while True:
+                msg = await read_message(reader)
+                if msg is None:
+                    logger.warning("jdtls stdout closed — subprocess may have exited")
+                    self._available = False
+                    break
+
+                self._dispatch_message(msg)
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error("jdtls reader loop error: %s", e)
+            self._available = False
+
+    def _dispatch_message(self, msg: dict[str, Any]) -> None:
+        """Route a message from jdtls to the appropriate handler."""
+        if "id" in msg and "method" not in msg:
+            # Response to a request we sent
+            request_id = msg["id"]
+            future = self._pending.pop(request_id, None)
+            if future and not future.done():
+                if "error" in msg:
+                    logger.warning("jdtls error response (id=%s): %s", request_id, msg["error"])
+                    future.set_result(None)
+                else:
+                    future.set_result(msg.get("result"))
+        elif "method" in msg and "id" not in msg:
+            # Notification from jdtls
+            self._handle_notification(msg)
+
+    def _handle_notification(self, msg: dict[str, Any]) -> None:
+        """Handle a notification from jdtls."""
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        if method == "textDocument/publishDiagnostics":
+            uri = params.get("uri", "")
+            diagnostics = params.get("diagnostics", [])
+            self._diagnostics_cache[uri] = diagnostics
+            if self._on_diagnostics:
+                self._on_diagnostics(uri, diagnostics)
+        # Other notifications (window/logMessage, etc.) are silently ignored