php-parser-py 1.0.0__tar.gz → 1.1.1__tar.gz

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: php-parser-py
-Version: 1.0.0
+Version: 1.1.1
 Summary: Python wrapper for PHP-Parser using cpg2py
 Author: samhsu-dev
 Author-email: samhsu-dev <yxu166@jh.edu>
@@ -52,7 +52,7 @@ nodes = parse_code(code)
 # Returns list of Node instances (no project/file structure)
 
 for node in nodes:
-    print(f"Node type: {node.label}")
+    print(f"Node type: {node.node_type}")
 ```
 
 ### Parse PHP File (With Project Structure)
@@ -69,34 +69,40 @@ files = ast.files()
 print(f"Project has {len(files)} file(s)")
 
 # Get file containing a specific node
-stmt_node = ast.first_node(lambda n: n.label == "Stmt_Function")
+stmt_node = ast.first_node(lambda n: n.node_type == "Stmt_Function")
 file_node = ast.get_file(stmt_node.id)
 print(f"Function is in file: {file_node.get_property('filePath')}")
 ```
 
-### Parse Multiple Files (Project Structure)
+### Parse Project Directory
 
 ```python
 from php_parser_py import parse_project
+from pathlib import Path
 
-# Parse multiple files into a single AST
-ast = parse_project(["file1.php", "file2.php", "file3.php"])
+# Parse all PHP files in a project directory (recursively)
+ast = parse_project("/path/to/project")
 
 # Access all files
 for file_node in ast.files():
     print(f"File: {file_node.get_property('filePath')}")
     # Get statements in this file
-    for stmt in ast.children(file_node):
-        print(f"  Statement: {stmt.label}")
+    for stmt in ast.succ(file_node):
+        print(f"  Statement: {stmt.node_type}")
 
 # Access project and file paths
-ast = parse_project(["file1.php", "subdir/file2.php"])
 project = ast.project_node
 print(f"Project root: {project.get_property('path')}")
 
 for file_node in ast.files():
     print(f"File relative path: {file_node.get_property('path')}")
     print(f"File absolute path: {file_node.get_property('filePath')}")
+
+# Use custom file filter (e.g., include .php and .phtml files)
+ast = parse_project(
+    "/path/to/project",
+    file_filter=lambda p: p.suffix in ['.php', '.phtml']
+)
 ```
 
 ### Traverse AST
@@ -107,19 +113,19 @@ from php_parser_py import parse_file
 ast = parse_file("example.php")
 
 # Find all echo statements
-for echo in ast.nodes(lambda n: n.label == "Stmt_Echo"):
-    print(f"Echo at line {echo.get_property('startLine')}")
+for echo in ast.nodes(lambda n: n.node_type == "Stmt_Echo"):
+    print(f"Echo at line {echo.start_line}")
 
 # Get children of a node (via PARENT_OF edges)
 for child in ast.succ(some_node):
-    print(f"Child type: {child.label}")
+    print(f"Child type: {child.node_type}")
 
 # Get all descendants
 for descendant in ast.descendants(some_node):
-    print(f"Descendant: {descendant.label}")
+    print(f"Descendant: {descendant.node_type}")
 
 # Get file containing a node
-stmt_node = ast.first_node(lambda n: n.label == "Stmt_Function")
+stmt_node = ast.first_node(lambda n: n.node_type == "Stmt_Function")
 file_node = ast.get_file(stmt_node.id)
 if file_node:
     print(f"Function is in: {file_node.get_property('filePath')}")
@@ -146,12 +152,12 @@ for file_path, code in generated.items():
     print(f"File: {file_path}")
     print(code)
 
-# Parse multiple files
-ast = parse_project(["file1.php", "file2.php"])
+# Parse project directory (recursively finds all PHP files)
+ast = parse_project("/path/to/project")
 
 # Generate code for all files
 generated = printer.print(ast)
-# Returns: {"file1.php": "...", "file2.php": "..."}
+# Returns: {"src/file1.php": "...", "src/file2.php": "..."}
 ```
 
 ## Advanced Usage
@@ -180,7 +186,7 @@ ast = parser.parse("<?php echo 'hello';")
 - **`parse_code(code: str) -> list[Node]`**: Parse PHP code string into raw statement nodes (no project/file structure)
 - **`parse(code: str) -> AST`**: Parse PHP code string and return AST with project/file structure (backward compatibility)
 - **`parse_file(path: str) -> AST`**: Parse a single PHP file and return AST with project/file structure
-- **`parse_project(paths: list[str]) -> AST`**: Parse multiple PHP files into a single AST with project structure
+- **`parse_project(project_path: str, file_filter: Callable[[Path], bool] = lambda p: p.suffix == '.php') -> AST`**: Parse all PHP files in a project directory into a single AST with project structure. `file_filter` function to customize which files are included (defaults to `.php` suffix check)
 
 ### Classes
 
@@ -200,10 +206,12 @@ ast = parser.parse("<?php echo 'hello';")
 
 - **`Node`**: Wraps a single AST node
   - `id`: Node identifier
-  - `label`: Node type (e.g., "Stmt_Function")
-  - `node_type`: Alias for label (PHP-Parser node type)
-  - `properties`: All node properties
+  - `node_type`: Node type (e.g., "Stmt_Function") - returns `nodeType` property
+  - `all_properties`: All node properties as dict
   - `get_property(*names)`: Get property value
+  - `start_line`, `end_line`: Line number properties
+  - `__getitem__(key)`: Dict-like access (e.g., `node["name"]`)
+  - `get(key, default)`: Get property with default value
 
 - **`Parser`**: Parses PHP code
   - `__init__(php_binary_path=None, php_binary_url=None)`: Initialize parser
@@ -212,7 +220,7 @@ ast = parser.parse("<?php echo 'hello';")
   - `parse_code(code)`: Parse code string into list of nodes
   - `parse(code)`: Parse code string into AST (backward compatibility)
   - `parse_file(path)`: Parse file into AST with project/file structure
-  - `parse_project(paths)`: Parse multiple files into AST with project structure
+  - `parse_project(project_path)`: Parse project directory into AST with project structure
 
 - **`PrettyPrinter`**: Generates PHP code
   - `__init__(php_binary_path=None, php_binary_url=None)`: Initialize printer

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/README.md

@@ -41,7 +41,7 @@ nodes = parse_code(code)
 # Returns list of Node instances (no project/file structure)
 
 for node in nodes:
-    print(f"Node type: {node.label}")
+    print(f"Node type: {node.node_type}")
 ```
 
 ### Parse PHP File (With Project Structure)
@@ -58,34 +58,40 @@ files = ast.files()
 print(f"Project has {len(files)} file(s)")
 
 # Get file containing a specific node
-stmt_node = ast.first_node(lambda n: n.label == "Stmt_Function")
+stmt_node = ast.first_node(lambda n: n.node_type == "Stmt_Function")
 file_node = ast.get_file(stmt_node.id)
 print(f"Function is in file: {file_node.get_property('filePath')}")
 ```
 
-### Parse Multiple Files (Project Structure)
+### Parse Project Directory
 
 ```python
 from php_parser_py import parse_project
+from pathlib import Path
 
-# Parse multiple files into a single AST
-ast = parse_project(["file1.php", "file2.php", "file3.php"])
+# Parse all PHP files in a project directory (recursively)
+ast = parse_project("/path/to/project")
 
 # Access all files
 for file_node in ast.files():
     print(f"File: {file_node.get_property('filePath')}")
     # Get statements in this file
-    for stmt in ast.children(file_node):
-        print(f"  Statement: {stmt.label}")
+    for stmt in ast.succ(file_node):
+        print(f"  Statement: {stmt.node_type}")
 
 # Access project and file paths
-ast = parse_project(["file1.php", "subdir/file2.php"])
 project = ast.project_node
 print(f"Project root: {project.get_property('path')}")
 
 for file_node in ast.files():
     print(f"File relative path: {file_node.get_property('path')}")
     print(f"File absolute path: {file_node.get_property('filePath')}")
+
+# Use custom file filter (e.g., include .php and .phtml files)
+ast = parse_project(
+    "/path/to/project",
+    file_filter=lambda p: p.suffix in ['.php', '.phtml']
+)
 ```
 
 ### Traverse AST
@@ -96,19 +102,19 @@ from php_parser_py import parse_file
 ast = parse_file("example.php")
 
 # Find all echo statements
-for echo in ast.nodes(lambda n: n.label == "Stmt_Echo"):
-    print(f"Echo at line {echo.get_property('startLine')}")
+for echo in ast.nodes(lambda n: n.node_type == "Stmt_Echo"):
+    print(f"Echo at line {echo.start_line}")
 
 # Get children of a node (via PARENT_OF edges)
 for child in ast.succ(some_node):
-    print(f"Child type: {child.label}")
+    print(f"Child type: {child.node_type}")
 
 # Get all descendants
 for descendant in ast.descendants(some_node):
-    print(f"Descendant: {descendant.label}")
+    print(f"Descendant: {descendant.node_type}")
 
 # Get file containing a node
-stmt_node = ast.first_node(lambda n: n.label == "Stmt_Function")
+stmt_node = ast.first_node(lambda n: n.node_type == "Stmt_Function")
 file_node = ast.get_file(stmt_node.id)
 if file_node:
     print(f"Function is in: {file_node.get_property('filePath')}")
@@ -135,12 +141,12 @@ for file_path, code in generated.items():
     print(f"File: {file_path}")
     print(code)
 
-# Parse multiple files
-ast = parse_project(["file1.php", "file2.php"])
+# Parse project directory (recursively finds all PHP files)
+ast = parse_project("/path/to/project")
 
 # Generate code for all files
 generated = printer.print(ast)
-# Returns: {"file1.php": "...", "file2.php": "..."}
+# Returns: {"src/file1.php": "...", "src/file2.php": "..."}
 ```
 
 ## Advanced Usage
@@ -169,7 +175,7 @@ ast = parser.parse("<?php echo 'hello';")
 - **`parse_code(code: str) -> list[Node]`**: Parse PHP code string into raw statement nodes (no project/file structure)
 - **`parse(code: str) -> AST`**: Parse PHP code string and return AST with project/file structure (backward compatibility)
 - **`parse_file(path: str) -> AST`**: Parse a single PHP file and return AST with project/file structure
-- **`parse_project(paths: list[str]) -> AST`**: Parse multiple PHP files into a single AST with project structure
+- **`parse_project(project_path: str, file_filter: Callable[[Path], bool] = lambda p: p.suffix == '.php') -> AST`**: Parse all PHP files in a project directory into a single AST with project structure. `file_filter` function to customize which files are included (defaults to `.php` suffix check)
 
 ### Classes
 
@@ -189,10 +195,12 @@ ast = parser.parse("<?php echo 'hello';")
 
 - **`Node`**: Wraps a single AST node
   - `id`: Node identifier
-  - `label`: Node type (e.g., "Stmt_Function")
-  - `node_type`: Alias for label (PHP-Parser node type)
-  - `properties`: All node properties
+  - `node_type`: Node type (e.g., "Stmt_Function") - returns `nodeType` property
+  - `all_properties`: All node properties as dict
   - `get_property(*names)`: Get property value
+  - `start_line`, `end_line`: Line number properties
+  - `__getitem__(key)`: Dict-like access (e.g., `node["name"]`)
+  - `get(key, default)`: Get property with default value
 
 - **`Parser`**: Parses PHP code
   - `__init__(php_binary_path=None, php_binary_url=None)`: Initialize parser
@@ -201,7 +209,7 @@ ast = parser.parse("<?php echo 'hello';")
   - `parse_code(code)`: Parse code string into list of nodes
   - `parse(code)`: Parse code string into AST (backward compatibility)
   - `parse_file(path)`: Parse file into AST with project/file structure
-  - `parse_project(paths)`: Parse multiple files into AST with project structure
+  - `parse_project(project_path)`: Parse project directory into AST with project structure
 
 - **`PrettyPrinter`**: Generates PHP code
   - `__init__(php_binary_path=None, php_binary_url=None)`: Initialize printer

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "php-parser-py"
-version = "1.0.0"
+version = "1.1.1"
 description = "Python wrapper for PHP-Parser using cpg2py"
 readme = "README.md"
 authors = [
@@ -25,5 +25,8 @@ source-include = ["resources/*.zip"]
 
 [dependency-groups]
 dev = [
+    "black>=26.1.0",
+    "isort>=7.0.0",
+    "pylint>=4.0.4",
     "pytest>=9.0.2",
 ]

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/__init__.py

@@ -5,6 +5,12 @@ This package provides a Python interface to PHP-Parser, enabling AST parsing
 and manipulation of PHP code.
 """
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Callable
+
 from php_parser_py._parser import Parser as _Parser
 from php_parser_py._printer import PrettyPrinter as _PrettyPrinter
 from php_parser_py._resources import ensure_php_parser_extracted
@@ -14,9 +20,9 @@ ensure_php_parser_extracted()
 
 # Import and expose public classes directly
 from php_parser_py._ast import AST
-from php_parser_py._node import Node
 from php_parser_py._edge import Edge
-from php_parser_py.exceptions import ParseError, RunnerError
+from php_parser_py._exceptions import ParseError, RunnerError
+from php_parser_py._node import Node
 
 
 class Parser(_Parser):
@@ -53,35 +59,6 @@ def parse_code(code: str) -> list[Node]:
     return parser.parse_code(code)
 
 
-def parse(code: str) -> AST:
-    """Parse PHP code string into an AST (backward compatibility).
-
-    This is a convenience function that creates a temporary project/file structure.
-    For code-only parsing without project structure, use parse_code() instead.
-
-    Args:
-        code: PHP source code string.
-
-    Returns:
-        AST instance with project -> file -> statements hierarchy.
-
-    Raises:
-        ParseError: If PHP-Parser reports syntax error.
-    """
-    # Create a temporary file-like structure for backward compatibility
-    import tempfile
-    from pathlib import Path
-    
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.php', delete=False) as f:
-        f.write(code)
-        temp_path = f.name
-    
-    try:
-        return parse_file(temp_path)
-    finally:
-        Path(temp_path).unlink()
-
-
 def parse_file(path: str) -> AST:
     """Read and parse a single PHP file into an AST.
 
@@ -102,25 +79,30 @@ def parse_file(path: str) -> AST:
     return parser.parse_file(path)
 
 
-def parse_project(paths: list[str], project_path: str | None = None) -> AST:
-    """Parse multiple PHP files into an AST.
+def parse_project(
+    project_path: str,
+    file_filter: "Callable[[Path], bool]" = lambda p: p.suffix == ".php",  # type: ignore
+) -> AST:
+    """Parse all PHP files in a project directory into an AST.
 
-    Creates a project node and multiple file nodes. Each file node
-    contains statements from its corresponding file.
+    Recursively traverses the project directory to find all PHP files,
+    then parses them into a single AST with project and file nodes.
 
     Args:
-        paths: List of file path strings.
-        project_path: Optional project root path. If not provided, computed as common parent.
+        project_path: Project root directory path.
+        file_filter: Function to filter files. Takes a Path and returns
+            True if the file should be parsed. Defaults to checking for `.php` suffix.
 
     Returns:
         AST instance with project -> files -> statements hierarchy.
 
     Raises:
         ParseError: If any file has syntax errors.
-        FileNotFoundError: If any file does not exist.
+        FileNotFoundError: If project directory does not exist.
+        ValueError: If project_path is not a directory.
     """
     parser = Parser()
-    return parser.parse_project(paths, project_path=project_path)
+    return parser.parse_project(project_path, file_filter=file_filter)
 
 
 __version__ = "0.1.0"

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_ast.py

@@ -119,7 +119,9 @@ class AST(AbcGraphQuerier[Node, Edge]):
         # Sort by file path for consistent ordering
         return sorted(file_nodes, key=lambda n: n.get_property("filePath", ""))
 
-    def get_file(self, node_id: str) -> Optional[Node]:
+    def get_file(
+        self, node_id: str
+    ) -> Optional[Node]:  # pylint: disable=too-many-return-statements
         """Get the file node that contains the given node.
 
         Traverses upward from the given node via PARENT_OF edges until
@@ -213,12 +215,12 @@ class AST(AbcGraphQuerier[Node, Edge]):
                 # Exclude project node if it exists
                 all_nodes = set(self._storage.get_nodes())
                 nodes_with_parents = set()
-                
+
                 for edge_id in self._storage.get_edges():
-                    from_id, to_id, edge_type = edge_id
+                    _, to_id, edge_type = edge_id
                     if edge_type == "PARENT_OF":
                         nodes_with_parents.add(to_id)
-                
+
                 root_nodes = all_nodes - nodes_with_parents
                 # Exclude project node if present
                 root_nodes.discard(self._root_node_id)
@@ -253,10 +255,20 @@ class AST(AbcGraphQuerier[Node, Edge]):
 
         return sorted(statement_nodes, key=get_index)
 
-    def _reconstruct_node(self, nid: str) -> dict[str, Any]:
-        """Recursively reconstruct JSON object for a node."""
+    def _reconstruct_node(  # pylint: disable=too-many-locals,too-many-branches,too-many-statements
+        self, nid: str
+    ) -> dict[str, Any]:
+        """Recursively reconstruct JSON object for a node.
+
+        Args:
+            nid: Node ID to reconstruct.
+
+        Returns:
+            Dictionary representing the node in PHP-Parser JSON format.
+        """
         props = self._storage.get_node_props(nid)
         if props is None:
+            logger.warning("Node %s not found in storage, returning empty dict", nid)
             return {}
 
         result: dict[str, Any] = {}
@@ -348,10 +360,12 @@ class AST(AbcGraphQuerier[Node, Edge]):
 
         # Add default values for common optional fields that PHP-Parser expects
         if node_type and ("attrGroups" not in result):
-            if (node_type.startswith("Stmt_") or 
-                node_type == "Param" or
-                node_type.startswith("Expr_Closure") or
-                node_type.startswith("Expr_ArrowFunction")):
+            if (
+                node_type.startswith("Stmt_")
+                or node_type == "Param"
+                or node_type.startswith("Expr_Closure")
+                or node_type.startswith("Expr_ArrowFunction")
+            ):
                 result["attrGroups"] = []
-        
+
         return result

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_edge.py

@@ -20,7 +20,9 @@ class Edge(AbcEdgeQuerier):
         _edge_id: Tuple of (from_id, to_id, edge_type).
     """
 
-    def __init__(self, graph: Storage, f_nid: str, t_nid: str, e_type: str = "PARENT_OF") -> None:
+    def __init__(
+        self, graph: Storage, f_nid: str, t_nid: str, e_type: str = "PARENT_OF"
+    ) -> None:
         """Initialize Edge with storage and edge identifiers.
 
         Args:

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_parser.py

@@ -3,14 +3,14 @@
 import hashlib
 import logging
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
 from cpg2py import Storage
 
 from php_parser_py._ast import AST
+from php_parser_py._exceptions import ParseError, RunnerError
 from php_parser_py._node import Node
 from php_parser_py._runner import Runner
-from php_parser_py.exceptions import ParseError, RunnerError
 
 logger = logging.getLogger(__name__)
 
@@ -21,7 +21,7 @@ class Parser:
     Provides three parsing methods:
     - parse_code: Parse code string, returns list of top-level statement nodes
     - parse_file: Parse single file, returns AST with project and file nodes
-    - parse_project: Parse multiple files, returns AST with project and multiple file nodes
+    - parse_project: Parse project directory, returns AST with project and all PHP files
 
     Attributes:
         _runner: Runner instance for PHP-Parser invocation.
@@ -33,7 +33,7 @@ class Parser:
         php_binary_url: Optional[str] = None,
     ) -> None:
         """Initialize Parser with Runner.
-        
+
         Args:
             php_binary_path: Optional path to local PHP binary.
             php_binary_url: Optional URL to download PHP binary from.
@@ -43,35 +43,6 @@ class Parser:
             php_binary_url=php_binary_url,
         )
 
-    def parse(self, code: str) -> AST:
-        """Parse PHP code string into an AST (backward compatibility).
-
-        Creates a temporary project/file structure. For code-only parsing
-        without project structure, use parse_code() instead.
-
-        Args:
-            code: PHP source code string.
-
-        Returns:
-            AST instance with project -> file -> statements hierarchy.
-
-        Raises:
-            ParseError: If code has syntax errors.
-            RunnerError: If PHP execution fails.
-        """
-        import tempfile
-        from pathlib import Path
-        
-        # Create temporary file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.php', delete=False) as f:
-            f.write(code)
-            temp_path = f.name
-        
-        try:
-            return self.parse_file(temp_path)
-        finally:
-            Path(temp_path).unlink()
-
     def parse_code(self, code: str) -> list[Node]:
         """Parse PHP code string into a list of top-level statement nodes.
 
@@ -105,7 +76,9 @@ class Parser:
         node_counter = [1]  # Use list to allow mutation in recursive calls
 
         for item in json_data:
-            node_id = self._process_node(storage, item, None, None, None, node_counter, "")
+            node_id = self._process_node(
+                storage, item, None, None, None, node_counter, ""
+            )
             if node_id:
                 node_ids.append(node_id)
 
@@ -140,7 +113,7 @@ class Parser:
         file_hash = hashlib.md5(str(file_path).encode()).hexdigest()[:8]
 
         code = file_path.read_text(encoding="utf-8")
-        
+
         try:
             json_data = self._runner.parse(code)
         except RunnerError as e:
@@ -153,63 +126,69 @@ class Parser:
             json_data = [json_data]
 
         storage = self._create_project_structure(
-            [(file_path, json_data)], 
+            [(file_path, json_data)],
             [(file_path, file_hash)],
-            project_path=project_path
+            project_path=project_path,
         )
         return AST(storage, root_node_id="project")
 
-    def parse_project(self, paths: list[str], project_path: str | None = None) -> AST:
-        """Parse multiple PHP files into an AST with project and file nodes.
+    def parse_project(
+        self,
+        project_path: str,
+        file_filter: Callable[[Path], bool] = lambda p: p.suffix == ".php",
+    ) -> AST:
+        """Parse all PHP files in a project directory into an AST.
 
-        Creates a project node (ID: "project") and multiple file nodes.
+        Recursively traverses the project directory to find all PHP files,
+        then parses them into a single AST with project and file nodes.
         Each file node has ID based on its path hash.
-        Project path is the common parent directory of all files, or the provided project_path.
 
         Args:
-            paths: List of file path strings.
-            project_path: Optional project root path. If not provided, computed as common parent.
+            project_path: Project root directory path.
+            file_filter: Function to filter files. Takes a Path and returns
+                True if the file should be parsed. Defaults to checking for `.php` suffix.
 
         Returns:
             AST instance with project -> files -> statements hierarchy.
 
         Raises:
             ParseError: If any file has syntax errors.
-            FileNotFoundError: If any file does not exist.
+            FileNotFoundError: If project directory does not exist.
+            ValueError: If project_path is not a directory.
         """
+        project_path_obj = Path(project_path).resolve()
+
+        if not project_path_obj.exists():
+            raise FileNotFoundError(f"Project directory not found: {project_path}")
+
+        if not project_path_obj.is_dir():
+            raise ValueError(f"Project path is not a directory: {project_path}")
+
+        # Find all files recursively and filter
+        all_files = project_path_obj.rglob("*")
+        php_files = [f for f in all_files if f.is_file() and file_filter(f)]
+
+        if not php_files:
+            logger.warning(f"No PHP files found in project directory: {project_path}")
+            # Create empty project structure
+            storage = Storage()
+            project_id = "project"
+            storage.add_node(project_id)
+            storage.set_node_props(
+                project_id,
+                {
+                    "nodeType": "Project",
+                    "label": "Project",
+                    "path": str(project_path_obj),
+                },
+            )
+            return AST(storage, root_node_id="project")
+
+        # Prepare file information
         file_infos = []
-        resolved_paths = []
-        for path in paths:
-            file_path = Path(path).resolve()
-            if not file_path.exists():
-                raise FileNotFoundError(f"File not found: {path}")
+        for file_path in php_files:
             file_hash = hashlib.md5(str(file_path).encode()).hexdigest()[:8]
             file_infos.append((file_path, file_hash))
-            resolved_paths.append(file_path)
-
-        # Determine project path
-        if project_path:
-            project_path = Path(project_path).resolve()
-        else:
-            # Compute common parent directory
-            if len(resolved_paths) == 1:
-                project_path = resolved_paths[0].parent
-            else:
-                # Find common parent
-                common_parts = None
-                for file_path in resolved_paths:
-                    parts = file_path.parts
-                    if common_parts is None:
-                        common_parts = parts
-                    else:
-                        # Find common prefix
-                        min_len = min(len(common_parts), len(parts))
-                        common_parts = [p for i, p in enumerate(common_parts[:min_len]) if parts[i] == p]
-                if common_parts:
-                    project_path = Path(*common_parts)
-                else:
-                    # Fallback to first file's parent
-                    project_path = resolved_paths[0].parent
 
         # Parse all files
         all_json_data = []
@@ -225,14 +204,16 @@ class Parser:
                     raise ParseError(f"Syntax error in {file_path}", line=1) from e
                 raise
 
-        storage = self._create_project_structure(all_json_data, file_infos, project_path=project_path)
+        storage = self._create_project_structure(
+            all_json_data, file_infos, project_path=project_path_obj
+        )
         return AST(storage, root_node_id="project")
 
     def _create_project_structure(
         self,
         files_data: list[tuple[Path, Any]],
         file_infos: list[tuple[Path, str]],
-        project_path: Path
+        project_path: Path,
     ) -> Storage:
         """Create AST structure with project -> files -> statements hierarchy.
 
@@ -249,11 +230,10 @@ class Parser:
         # Create project node (fixed ID: "project")
         project_id = "project"
         storage.add_node(project_id)
-        storage.set_node_props(project_id, {
-            "nodeType": "Project",
-            "label": "Project",
-            "path": str(project_path)
-        })
+        storage.set_node_props(
+            project_id,
+            {"nodeType": "Project", "label": "Project", "path": str(project_path)},
+        )
 
         # Create file nodes and process their statements
         for (file_path, file_hash), (_, json_data) in zip(file_infos, files_data):
@@ -267,12 +247,15 @@ class Parser:
             # Create file node (ID: hex hash)
             file_id = file_hash
             storage.add_node(file_id)
-            storage.set_node_props(file_id, {
-                "nodeType": "File",
-                "label": "File",
-                "filePath": str(file_path),  # Absolute path
-                "path": str(relative_path)   # Relative path from project root
-            })
+            storage.set_node_props(
+                file_id,
+                {
+                    "nodeType": "File",
+                    "label": "File",
+                    "filePath": str(file_path),  # Absolute path
+                    "path": str(relative_path),  # Relative path from project root
+                },
+            )
 
             # Link file to project
             edge_id = (project_id, file_id, "PARENT_OF")
@@ -291,7 +274,7 @@ class Parser:
 
         return storage
 
-    def _process_node(
+    def _process_node(  # pylint: disable=too-many-arguments,too-many-locals,too-many-branches
         self,
         storage: Storage,
         node_data: Any,
@@ -299,7 +282,7 @@ class Parser:
         field_name: str | None,
         index: int | None,
         node_counter: list[int],
-        prefix: str
+        prefix: str,
     ) -> str | None:
         """Process a single node and its children recursively.
 
@@ -383,7 +366,13 @@ class Parser:
             else:
                 # Single child object
                 self._process_node(
-                    storage, field_value, node_id, field_name, None, node_counter, prefix
+                    storage,
+                    field_value,
+                    node_id,
+                    field_name,
+                    None,
+                    node_counter,
+                    prefix,
                 )
 
         return node_id

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_printer.py

@@ -26,7 +26,7 @@ class PrettyPrinter:
         php_binary_url: Optional[str] = None,
     ) -> None:
         """Initialize PrettyPrinter with Runner.
-        
+
         Args:
             php_binary_path: Optional path to local PHP binary.
             php_binary_url: Optional URL to download PHP binary from.
@@ -44,34 +44,64 @@ class PrettyPrinter:
 
         Returns:
             Dictionary mapping file paths to generated PHP source code strings.
-            If AST has no file structure, returns a single entry with key "code"
-            or empty string.
+            If AST has no file structure, returns a single entry with key ""
+            as the filename.
 
         Raises:
             RunnerError: If PHP-Parser execution fails.
         """
         file_nodes = ast.files()
-        
+
         if not file_nodes:
             # No file structure - export all statements as a single code block
             json_str = ast.to_json()
             code = self._runner.print(json_str)
             return {"": code}
-        
+
         # Generate code for each file
         result: dict[str, str] = {}
         for file_node in file_nodes:
             file_path = file_node.get_property("filePath", "")
             file_hash = file_node.id
-            
+
             # Get JSON for this file only
             json_str = ast.to_json(file_hash=file_hash)
-            
+
             # Generate code
             code = self._runner.print(json_str)
-            
+
             # Use file path as key, or file hash if path not available
             key = file_path if file_path else file_hash
             result[key] = code
-        
+
         return result
+
+    def print_file(self, ast: AST, relative_path: str) -> str:
+        """Generate PHP code string for a single file selected by relative path.
+
+        This method looks up the file node whose ``path`` property matches the
+        given relative path (as stored on file nodes), reconstructs JSON for
+        that file only, and returns the generated PHP source code string.
+
+        Args:
+            ast: AST instance containing project and file nodes.
+            relative_path: Relative file path stored in the ``path`` property
+                of the target file node (for example, ``"src/file.php"`` or
+                just ``"file.php"`` for single-file projects).
+
+        Returns:
+            Generated PHP source code string for the specified file.
+
+        Raises:
+            KeyError: If no file node with the given relative path exists
+                in the AST.
+            RunnerError: If PHP-Parser execution fails.
+        """
+        # Find file node by its relative path property
+        for file_node in ast.files():
+            if file_node.get_property("path") == relative_path:
+                file_hash = file_node.id
+                json_str = ast.to_json(file_hash=file_hash)
+                return self._runner.print(json_str)
+
+        raise KeyError(f"File with relative path '{relative_path}' not found in AST.")

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_resources.py

@@ -12,7 +12,7 @@ from typing import Optional
 
 # Global lock for thread-safe extraction
 _extraction_lock = threading.Lock()
-_extraction_done = False
+_extraction_done = False  # pylint: disable=invalid-name
 
 
 def get_vendor_path() -> Path:

{php_parser_py-1.0.0 → php_parser_py-1.1.1}/src/php_parser_py/_runner.py

@@ -9,8 +9,8 @@ from typing import Any, Optional
 from static_php_py import PHP
 from static_php_py.exceptions import BinaryNotFoundError, DownloadError
 
+from php_parser_py._exceptions import ParseError, RunnerError
 from php_parser_py._resources import ensure_php_parser_extracted
-from php_parser_py.exceptions import ParseError, RunnerError
 
 logger = logging.getLogger(__name__)
 
@@ -105,7 +105,7 @@ class Runner:
                 if result.stdout:
                     logger.error(f"PHP stdout: {result.stdout}")
                     error_msg += f"\nStdout: {result.stdout}"
-                
+
                 raise RunnerError(
                     error_msg,
                     stderr=result.stderr,
@@ -117,18 +117,14 @@ class Runner:
         except FileNotFoundError as e:
             error_msg = f"PHP binary not found: {self._php_binary}"
             logger.error(error_msg)
-            raise RunnerError(
-                error_msg, stderr=str(e), exit_code=1
-            ) from e
+            raise RunnerError(error_msg, stderr=str(e), exit_code=1) from e
         except Exception as e:
             error_msg = f"Failed to execute PHP script: {e}"
             logger.error(error_msg)
             # Don't wrap the error if it's already a RunnerError
             if isinstance(e, RunnerError):
                 raise
-            raise RunnerError(
-                error_msg, stderr=str(e), exit_code=1
-            ) from e
+            raise RunnerError(error_msg, stderr=str(e), exit_code=1) from e
 
     def parse(self, code: str) -> dict[str, Any]:
         """Invoke PHP-Parser parse + JsonSerializer.