graphlens-php 0.7.0__py3-none-any.whl

graphlens_php/_module_resolver.py

@@ -0,0 +1,109 @@
+"""Namespace resolution and PSR-4 source-root detection for PHP."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def load_psr4_map(project_root: Path) -> dict[str, list[Path]]:
+    r"""
+    Return the project's PSR-4 namespace → directories map.
+
+    Reads both ``autoload`` and ``autoload-dev`` so that test namespaces are
+    treated as internal. Namespace keys are returned without their trailing
+    backslash (``"App\\"`` → ``"App"``). Directories are resolved relative to
+    ``project_root``. Returns ``{}`` on any error (never raises).
+    """
+    composer = project_root / "composer.json"
+    if not composer.exists():
+        return {}
+    try:
+        data = json.loads(composer.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    if not isinstance(data, dict):
+        return {}
+
+    out: dict[str, list[Path]] = {}
+    for section in ("autoload", "autoload-dev"):
+        block = data.get(section)
+        if not isinstance(block, dict):
+            continue
+        psr4 = block.get("psr-4")
+        if not isinstance(psr4, dict):
+            continue
+        for prefix, dirs in psr4.items():
+            if not isinstance(prefix, str):  # pragma: no cover
+                continue
+            namespace = prefix.rstrip("\\")
+            dir_list = [dirs] if isinstance(dirs, str) else dirs
+            if not isinstance(dir_list, list):
+                continue
+            resolved = [
+                (project_root / d) for d in dir_list if isinstance(d, str)
+            ]
+            out.setdefault(namespace, []).extend(resolved)
+    return out
+
+
+def internal_namespace_tops(project_root: Path) -> set[str]:
+    """Return the top-level segment of every PSR-4 namespace prefix."""
+    tops: set[str] = set()
+    for namespace in load_psr4_map(project_root):
+        if namespace:
+            tops.add(namespace.split("\\", maxsplit=1)[0])
+    return tops
+
+
+def find_source_roots(
+    project_root: Path,
+    files: list[Path],  # noqa: ARG001
+) -> list[Path]:
+    """
+    Detect PHP source roots from the PSR-4 autoload directories.
+
+    Every directory referenced by a PSR-4 prefix becomes a source root, with
+    ``project_root`` appended last as a catch-all so files outside any
+    declared PSR-4 tree are still attributable.
+    """
+    roots: list[Path] = []
+    for dirs in load_psr4_map(project_root).values():
+        for directory in dirs:
+            if directory.is_dir() and directory not in roots:
+                roots.append(directory)
+    if project_root not in roots:
+        roots.append(project_root)
+    return roots
+
+
+def path_to_namespace(file_path: Path, project_root: Path) -> str:
+    r"""
+    Map a file path to its PSR-4 namespace (the file's containing namespace).
+
+    This is a *fallback* used only when a file declares no ``namespace``
+    statement of its own — the in-source declaration is always authoritative
+    when present. For ``psr-4 {"App\\": "src/"}`` the file
+    ``src/Service/UserService.php`` maps to namespace ``App\\Service``.
+
+    Returns ``""`` (the global namespace) when no PSR-4 prefix matches.
+    """
+    psr4 = load_psr4_map(project_root)
+    best_namespace = ""
+    best_len = -1
+    for namespace, dirs in psr4.items():
+        for directory in dirs:
+            try:
+                relative = file_path.parent.relative_to(directory)
+            except ValueError:
+                continue
+            depth = len(directory.parts)
+            if depth <= best_len:
+                continue
+            sub = [p for p in relative.parts if p not in (".", "")]
+            best_namespace = "\\".join([namespace, *sub]) if sub else namespace
+            best_len = depth
+    return best_namespace

graphlens_php/_project_detector.py

@@ -0,0 +1,76 @@
+"""PHP project detection: marker files and project name extraction."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from graphlens.utils import collect_marker_roots
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+PHP_MARKERS: tuple[str, ...] = (
+    "composer.json",
+)
+
+EXCLUDED_DIRS: frozenset[str] = frozenset({
+    "vendor", "node_modules", ".git", "var", "cache",
+    "build", "dist", ".phpunit.cache",
+})
+
+
+def is_php_project(project_root: Path) -> bool:
+    """
+    Return True if the directory contains a PHP project.
+
+    Detection order:
+    1. PHP-specific marker files (composer.json)
+    2. Fallback: any ``.php`` file exists anywhere under project_root
+
+    The fallback handles multi-language monorepos and plain PHP projects
+    that ship no composer manifest.
+    """
+    if (project_root / "composer.json").exists():
+        return True
+    return any(project_root.rglob("*.php"))
+
+
+def find_php_roots(search_root: Path) -> list[Path]:
+    """
+    Find the actual PHP project roots within search_root.
+
+    Walks for ``composer.json`` markers and returns their parent
+    directories — one per distinct PHP sub-project. A marker at
+    ``search_root`` does not hide nested marker roots, so a monorepo that is
+    itself a project and also contains PHP sub-packages yields every root.
+
+    Falls back to ``[search_root]`` when no markers are found anywhere (a
+    directory that contains only bare ``.php`` scripts with no manifest).
+    """
+    return collect_marker_roots(
+        search_root,
+        PHP_MARKERS,
+        excluded_dirs=EXCLUDED_DIRS,
+    )
+
+
+def detect_project_name(project_root: Path) -> str:
+    """
+    Extract the project name.
+
+    Resolution order:
+    1. composer.json ``name`` (e.g. ``vendor/package``)
+    2. project_root directory name
+    """
+    composer = project_root / "composer.json"
+    if composer.exists():
+        try:
+            data = json.loads(composer.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            data = {}
+        name = data.get("name") if isinstance(data, dict) else None
+        if isinstance(name, str) and name:
+            return name
+
+    return project_root.name