codemap-php 0.1.0a1__tar.gz

codemap_php-0.1.0a1/.gitignore

@@ -0,0 +1,43 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.tox/
+.mypy_cache/
+.ruff_cache/
+.benchmarks/
+
+# Virtualenv
+.venv/
+venv/
+env/
+
+# uv / pdm lockfiles (commit uv.lock once we settle)
+# uv.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# CodeMap own index when dogfooding
+.codemap/

codemap_php-0.1.0a1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: codemap-php
+Version: 0.1.0a1
+Summary: PHP indexer plugin for CodeMap
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: codemap,indexer,php,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: PHP
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.2,>=0.1.0a1
+Requires-Dist: tree-sitter-php>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-php
+
+> A PHP indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> shipped as an independent PyPI package.
+
+## What it captures
+
+Backed by `tree-sitter-php`:
+
+| AST node | Symbol kind |
+|---|---|
+| `class_declaration` | `class` (with `extra.php_kind=class`) |
+| `interface_declaration` | `class` (with `extra.php_kind=interface`) |
+| `trait_declaration` | `class` (with `extra.php_kind=trait`) |
+| `enum_declaration` | `class` (with `extra.php_kind=enum`) |
+| `method_declaration` (inside type) | `method` |
+| `function_definition` (top level) | `function` |
+| `property_declaration` (inside type) | `field` |
+| `const_declaration` (top level) | `variable` |
+| `const_declaration` (inside type) | `field` |
+
+`namespace_definition` is captured as `extra.namespace` on every
+symbol-producing type.
+
+## Install
+
+```bash
+pip install "git+https://github.com/qxbyte/codemap.git#subdirectory=plugins/codemap-php"
+```
+
+## SymbolID encoding
+
+```
+scip-php . . . src/App/User.php/User#hello().
+```
+
+## Limits
+
+* Use statements aren't yet expanded into namespace-resolved edges.
+* PHPDoc annotations are not parsed.
+* Anonymous classes are skipped.
+
+## License
+
+MIT.

codemap_php-0.1.0a1/README.md

@@ -0,0 +1,45 @@
+# codemap-php
+
+> A PHP indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> shipped as an independent PyPI package.
+
+## What it captures
+
+Backed by `tree-sitter-php`:
+
+| AST node | Symbol kind |
+|---|---|
+| `class_declaration` | `class` (with `extra.php_kind=class`) |
+| `interface_declaration` | `class` (with `extra.php_kind=interface`) |
+| `trait_declaration` | `class` (with `extra.php_kind=trait`) |
+| `enum_declaration` | `class` (with `extra.php_kind=enum`) |
+| `method_declaration` (inside type) | `method` |
+| `function_definition` (top level) | `function` |
+| `property_declaration` (inside type) | `field` |
+| `const_declaration` (top level) | `variable` |
+| `const_declaration` (inside type) | `field` |
+
+`namespace_definition` is captured as `extra.namespace` on every
+symbol-producing type.
+
+## Install
+
+```bash
+pip install "git+https://github.com/qxbyte/codemap.git#subdirectory=plugins/codemap-php"
+```
+
+## SymbolID encoding
+
+```
+scip-php . . . src/App/User.php/User#hello().
+```
+
+## Limits
+
+* Use statements aren't yet expanded into namespace-resolved edges.
+* PHPDoc annotations are not parsed.
+* Anonymous classes are skipped.
+
+## License
+
+MIT.

codemap_php-0.1.0a1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codemap-php"
+version = "0.1.0a1"
+description = "PHP indexer plugin for CodeMap"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "CodeMap Contributors" }]
+keywords = ["codemap", "php", "indexer", "tree-sitter"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: PHP",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "codemap-core>=0.1.0a1,<0.2",
+    "tree-sitter>=0.25",
+    "tree-sitter-php>=0.23",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.entry-points."codemap.indexers"]
+php = "codemap_php:PhpIndexer"
+
+[project.urls]
+Homepage = "https://github.com/qxbyte/codemap"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codemap_php"]

codemap_php-0.1.0a1/src/codemap_php/__init__.py

@@ -0,0 +1,8 @@
+"""PHP indexer plugin for CodeMap."""
+
+from __future__ import annotations
+
+from codemap_php.indexer import PhpIndexer
+
+__all__ = ["PhpIndexer"]
+__version__ = "0.1.0"

codemap_php-0.1.0a1/src/codemap_php/indexer.py

@@ -0,0 +1,293 @@
+"""PHP indexer built on tree-sitter-php.
+
+Handles all four PHP type declarations (``class`` / ``interface`` /
+``trait`` / ``enum``) with their respective bodies, plus free
+``function_definition`` and module-level ``const_declaration``.
+``namespace_definition`` is honoured as ``extra.namespace`` on every
+type symbol; nested types share the same single namespace (PHP doesn't
+allow nested classes the way Java does, but the tree-sitter grammar
+permits it).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_php
+
+from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+
+SCHEME = "scip-php"
+LANG = "php"
+
+_PHP_LANG = tree_sitter.Language(tree_sitter_php.language_php())
+
+_TYPE_DECLS: dict[str, str] = {
+    "class_declaration": "class",
+    "interface_declaration": "interface",
+    "trait_declaration": "trait",
+    "enum_declaration": "enum",
+}
+
+
+class PhpIndexer:
+    name: ClassVar[str] = "php"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.php"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix == ".php"
+
+    def index_file(
+        self,
+        path: Path,
+        source: bytes,
+        ctx: IndexContext,
+    ) -> IndexResult:
+        try:
+            source.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="error",
+                        file=ctx.relative_path,
+                        code="PHP002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        parser = tree_sitter.Parser(_PHP_LANG)
+        tree = parser.parse(source)
+        visitor = _Visitor(ctx.relative_path)
+        visitor.visit(tree.root_node)
+        diagnostics = list(visitor.diagnostics)
+        if tree.root_node.has_error:
+            diagnostics.append(
+                Diagnostic(
+                    severity="warning",
+                    file=ctx.relative_path,
+                    range=Range(start_line=1, end_line=1),
+                    code="PHP001",
+                    message="tree-sitter reported parse errors; symbols may be incomplete",
+                    producer=self.name,
+                )
+            )
+        return IndexResult(
+            symbols=visitor.symbols,
+            edges=visitor.edges,
+            diagnostics=diagnostics,
+        )
+
+
+class _Visitor:
+    def __init__(self, relative_path: PurePosixPath) -> None:
+        self.relative_path = relative_path
+        self.symbols: list[Symbol] = []
+        self.edges: list[Edge] = []
+        self.diagnostics: list[Diagnostic] = []
+        self._type_stack: list[str] = []
+        self._namespace: str = ""
+
+    def visit(self, node: tree_sitter.Node) -> None:
+        kind = node.type
+        if kind == "namespace_definition":
+            self._set_namespace(node)
+            return
+        if kind in _TYPE_DECLS:
+            self._visit_type(node, php_kind=_TYPE_DECLS[kind])
+            return
+        if kind == "function_definition":
+            self._visit_function(node)
+            return
+        if kind == "method_declaration" and self._type_stack:
+            self._visit_method(node)
+            return
+        if kind == "property_declaration" and self._type_stack:
+            self._visit_property(node)
+            return
+        if kind == "const_declaration":
+            self._visit_const(node)
+            return
+        for child in node.children:
+            self.visit(child)
+
+    # ------------------------------------------------- namespace
+
+    def _set_namespace(self, node: tree_sitter.Node) -> None:
+        for child in node.children:
+            if child.type == "namespace_name":
+                self._namespace = _node_text(child)
+                return
+
+    # ------------------------------------------------------- types
+
+    def _visit_type(self, node: tree_sitter.Node, *, php_kind: str) -> None:
+        name = _name_child(node)
+        if name is None:
+            return
+        sid = self._make_id(name, kind=DescriptorKind.TYPE)
+        extra: dict[str, str] = {"php_kind": php_kind}
+        if self._namespace:
+            extra["namespace"] = self._namespace
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra=extra,
+            )
+        )
+        body = _declaration_list(node)
+        if body is None:
+            return
+        self._type_stack.append(name)
+        try:
+            for child in body.children:
+                self.visit(child)
+        finally:
+            self._type_stack.pop()
+
+    # --------------------------------------------------- functions
+
+    def _visit_function(self, node: tree_sitter.Node) -> None:
+        if self._type_stack:
+            # Function defined inside a class body (rare but legal in some
+            # grammars) — treat as method.
+            self._visit_method(node)
+            return
+        name = _name_child(node)
+        if name is None:
+            return
+        sid = self._make_id(name, kind=DescriptorKind.METHOD)
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="function",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                signature=f"function {name}()",
+            )
+        )
+
+    def _visit_method(self, node: tree_sitter.Node) -> None:
+        name = _name_child(node)
+        if name is None:
+            return
+        sid = self._make_id(name, kind=DescriptorKind.METHOD)
+        self.symbols.append(
+            Symbol(
+                id=sid,
+                kind="method",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                signature=f"function {name}()",
+            )
+        )
+
+    # --------------------------------------------------- properties
+
+    def _visit_property(self, node: tree_sitter.Node) -> None:
+        # property_declaration > property_element > variable_name
+        for child in node.children:
+            if child.type == "property_element":
+                for grand in child.children:
+                    if grand.type == "variable_name":
+                        # variable_name has a single name child (without '$')
+                        for great in grand.children:
+                            if great.type == "name":
+                                name = _node_text(great)
+                                if not name:
+                                    return
+                                sid = self._make_id(name, kind=DescriptorKind.TERM)
+                                self.symbols.append(
+                                    Symbol(
+                                        id=sid,
+                                        kind="field",
+                                        language=LANG,
+                                        file=self.relative_path,
+                                        range=_node_range(node),
+                                    )
+                                )
+                                return
+
+    # ------------------------------------------------ const decls
+
+    def _visit_const(self, node: tree_sitter.Node) -> None:
+        # const_declaration > const_element > name
+        for child in node.children:
+            if child.type != "const_element":
+                continue
+            for grand in child.children:
+                if grand.type == "name":
+                    name = _node_text(grand)
+                    if not name:
+                        return
+                    sym_kind: str = "field" if self._type_stack else "variable"
+                    sid = self._make_id(name, kind=DescriptorKind.TERM)
+                    self.symbols.append(
+                        Symbol(
+                            id=sid,
+                            kind=sym_kind,  # type: ignore[arg-type]
+                            language=LANG,
+                            file=self.relative_path,
+                            range=_node_range(node),
+                        )
+                    )
+                    return
+
+    # -------------------------------------------------------- helpers
+
+    def _make_id(self, name: str, *, kind: DescriptorKind) -> SymbolID:
+        descriptors = list(_path_namespaces(self.relative_path))
+        descriptors.extend(Descriptor(name=t, kind=DescriptorKind.TYPE) for t in self._type_stack)
+        descriptors.append(Descriptor(name=name, kind=kind))
+        return SymbolID(scheme=SCHEME, descriptors=tuple(descriptors))
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+def _node_range(node: tree_sitter.Node) -> Range:
+    sr, sc = node.start_point
+    er, ec = node.end_point
+    return Range(
+        start_line=sr + 1,
+        start_col=sc,
+        end_line=max(er + 1, sr + 1),
+        end_col=ec,
+    )
+
+
+def _node_text(node: tree_sitter.Node) -> str:
+    return node.text.decode("utf-8") if node.text is not None else ""
+
+
+def _name_child(node: tree_sitter.Node) -> str | None:
+    for child in node.children:
+        if child.type == "name":
+            return _node_text(child)
+    return None
+
+
+def _declaration_list(node: tree_sitter.Node) -> tree_sitter.Node | None:
+    for child in node.children:
+        if child.type in {"declaration_list", "enum_declaration_list"}:
+            return child
+    return None

codemap_php-0.1.0a1/tests/test_indexer.py

@@ -0,0 +1,169 @@
+"""Unit tests for the PHP indexer plugin."""
+
+from __future__ import annotations
+
+import textwrap
+from pathlib import Path, PurePosixPath
+
+from codemap_php import PhpIndexer
+from codemap_php.indexer import SCHEME
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+
+def _index(source: str, *, path: str = "src/User.php") -> IndexResult:
+    code = textwrap.dedent(source).lstrip("\n")
+    return PhpIndexer().index_file(
+        Path(path),
+        code.encode("utf-8"),
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath(path),
+            language="php",
+        ),
+    )
+
+
+def test_indexer_metadata() -> None:
+    ix = PhpIndexer()
+    assert ix.name == "php"
+    assert ix.languages == ["php"]
+    assert ix.supports(Path("a.php"))
+    assert not ix.supports(Path("a.py"))
+
+
+def test_scheme_is_consistent() -> None:
+    r = _index(
+        """
+        <?php
+        class A {}
+        function f() {}
+        const X = 1;
+        """
+    )
+    for s in r.symbols:
+        assert str(s.id).startswith(f"{SCHEME} ")
+
+
+def test_class_declaration() -> None:
+    r = _index(
+        """
+        <?php
+        class User {
+            public string $name;
+            public function hello(): string { return $this->name; }
+        }
+        """
+    )
+    classes = [s for s in r.symbols if s.kind == "class"]
+    assert classes[0].extra.get("php_kind") == "class"
+    methods = [s for s in r.symbols if s.kind == "method"]
+    assert any("User#hello()." in str(m.id) for m in methods)
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert any("User#name." in str(f.id) for f in fields)
+
+
+def test_interface_declaration() -> None:
+    r = _index(
+        """
+        <?php
+        interface Greeter {
+            public function hello(): string;
+        }
+        """
+    )
+    cls = next(s for s in r.symbols if s.kind == "class")
+    assert cls.extra.get("php_kind") == "interface"
+
+
+def test_trait_declaration() -> None:
+    r = _index(
+        """
+        <?php
+        trait Loggable {
+            public function log() {}
+        }
+        """
+    )
+    cls = next(s for s in r.symbols if s.kind == "class")
+    assert cls.extra.get("php_kind") == "trait"
+
+
+def test_namespace_captured_in_extra() -> None:
+    r = _index(
+        """
+        <?php
+        namespace App\\Models;
+        class User {}
+        """
+    )
+    cls = next(s for s in r.symbols if s.kind == "class")
+    assert "App" in cls.extra.get("namespace", "")
+
+
+def test_free_function() -> None:
+    r = _index("<?php\nfunction helper(int $x): int { return $x + 1; }")
+    funcs = [s for s in r.symbols if s.kind == "function"]
+    assert len(funcs) == 1
+    assert "helper" in str(funcs[0].id)
+
+
+def test_top_level_const_is_variable() -> None:
+    r = _index("<?php\nconst MAX = 10;")
+    vars_ = [s for s in r.symbols if s.kind == "variable"]
+    assert len(vars_) == 1
+
+
+def test_const_inside_class_is_field() -> None:
+    r = _index(
+        """
+        <?php
+        class A {
+            const DEFAULT = 1;
+        }
+        """
+    )
+    fields = [s for s in r.symbols if s.kind == "field"]
+    assert any("DEFAULT" in str(f.id) for f in fields)
+
+
+def test_static_method_recorded() -> None:
+    r = _index(
+        """
+        <?php
+        class User {
+            public static function create(string $name): User {
+                return new User();
+            }
+        }
+        """
+    )
+    methods = [s for s in r.symbols if s.kind == "method"]
+    assert any("create" in str(m.id) for m in methods)
+
+
+def test_symbol_id_uses_path_namespaces() -> None:
+    r = _index("<?php\nclass A {}", path="src/App/A.php")
+    cls = next(s for s in r.symbols if s.kind == "class")
+    assert str(cls.id) == "scip-php . . . src/App/A.php/A#"
+
+
+def test_empty_file_yields_no_symbols() -> None:
+    r = _index("")
+    assert r.symbols == []
+
+
+def test_invalid_utf8_yields_diagnostic() -> None:
+    ix = PhpIndexer()
+    r = ix.index_file(
+        Path("bad.php"),
+        b"\xff\xfe<?php",
+        IndexContext(
+            project_root=Path("/tmp/proj"),
+            relative_path=PurePosixPath("bad.php"),
+            language="php",
+        ),
+    )
+    assert r.symbols == []
+    assert r.diagnostics[0].code == "PHP002"